netdev: Add netdev->addr_list_lock protection.
[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 {
1603         if (likely(!skb->next)) {
1604                 if (!list_empty(&ptype_all))
1605                         dev_queue_xmit_nit(skb, dev);
1606
1607                 if (netif_needs_gso(dev, skb)) {
1608                         if (unlikely(dev_gso_segment(skb)))
1609                                 goto out_kfree_skb;
1610                         if (skb->next)
1611                                 goto gso;
1612                 }
1613
1614                 return dev->hard_start_xmit(skb, dev);
1615         }
1616
1617 gso:
1618         do {
1619                 struct sk_buff *nskb = skb->next;
1620                 int rc;
1621
1622                 skb->next = nskb->next;
1623                 nskb->next = NULL;
1624                 rc = dev->hard_start_xmit(nskb, dev);
1625                 if (unlikely(rc)) {
1626                         nskb->next = skb->next;
1627                         skb->next = nskb;
1628                         return rc;
1629                 }
1630                 if (unlikely((netif_queue_stopped(dev) ||
1631                              netif_subqueue_stopped(dev, skb)) &&
1632                              skb->next))
1633                         return NETDEV_TX_BUSY;
1634         } while (skb->next);
1635
1636         skb->destructor = DEV_GSO_CB(skb)->destructor;
1637
1638 out_kfree_skb:
1639         kfree_skb(skb);
1640         return 0;
1641 }
1642
1643 /**
1644  *      dev_queue_xmit - transmit a buffer
1645  *      @skb: buffer to transmit
1646  *
1647  *      Queue a buffer for transmission to a network device. The caller must
1648  *      have set the device and priority and built the buffer before calling
1649  *      this function. The function can be called from an interrupt.
1650  *
1651  *      A negative errno code is returned on a failure. A success does not
1652  *      guarantee the frame will be transmitted as it may be dropped due
1653  *      to congestion or traffic shaping.
1654  *
1655  * -----------------------------------------------------------------------------------
1656  *      I notice this method can also return errors from the queue disciplines,
1657  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
1658  *      be positive.
1659  *
1660  *      Regardless of the return value, the skb is consumed, so it is currently
1661  *      difficult to retry a send to this method.  (You can bump the ref count
1662  *      before sending to hold a reference for retry if you are careful.)
1663  *
1664  *      When calling this method, interrupts MUST be enabled.  This is because
1665  *      the BH enable code must have IRQs enabled so that it will not deadlock.
1666  *          --BLG
1667  */
1668
1669 int dev_queue_xmit(struct sk_buff *skb)
1670 {
1671         struct net_device *dev = skb->dev;
1672         struct netdev_queue *txq;
1673         struct Qdisc *q;
1674         int rc = -ENOMEM;
1675
1676         /* GSO will handle the following emulations directly. */
1677         if (netif_needs_gso(dev, skb))
1678                 goto gso;
1679
1680         if (skb_shinfo(skb)->frag_list &&
1681             !(dev->features & NETIF_F_FRAGLIST) &&
1682             __skb_linearize(skb))
1683                 goto out_kfree_skb;
1684
1685         /* Fragmented skb is linearized if device does not support SG,
1686          * or if at least one of fragments is in highmem and device
1687          * does not support DMA from it.
1688          */
1689         if (skb_shinfo(skb)->nr_frags &&
1690             (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1691             __skb_linearize(skb))
1692                 goto out_kfree_skb;
1693
1694         /* If packet is not checksummed and device does not support
1695          * checksumming for this protocol, complete checksumming here.
1696          */
1697         if (skb->ip_summed == CHECKSUM_PARTIAL) {
1698                 skb_set_transport_header(skb, skb->csum_start -
1699                                               skb_headroom(skb));
1700                 if (!dev_can_checksum(dev, skb) && skb_checksum_help(skb))
1701                         goto out_kfree_skb;
1702         }
1703
1704 gso:
1705         txq = &dev->tx_queue;
1706         spin_lock_prefetch(&txq->lock);
1707
1708         /* Disable soft irqs for various locks below. Also
1709          * stops preemption for RCU.
1710          */
1711         rcu_read_lock_bh();
1712
1713         /* Updates of qdisc are serialized by queue->lock.
1714          * The struct Qdisc which is pointed to by qdisc is now a
1715          * rcu structure - it may be accessed without acquiring
1716          * a lock (but the structure may be stale.) The freeing of the
1717          * qdisc will be deferred until it's known that there are no
1718          * more references to it.
1719          *
1720          * If the qdisc has an enqueue function, we still need to
1721          * hold the queue->lock before calling it, since queue->lock
1722          * also serializes access to the device queue.
1723          */
1724
1725         q = rcu_dereference(txq->qdisc);
1726 #ifdef CONFIG_NET_CLS_ACT
1727         skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1728 #endif
1729         if (q->enqueue) {
1730                 /* Grab device queue */
1731                 spin_lock(&txq->lock);
1732                 q = txq->qdisc;
1733                 if (q->enqueue) {
1734                         /* reset queue_mapping to zero */
1735                         skb_set_queue_mapping(skb, 0);
1736                         rc = q->enqueue(skb, q);
1737                         qdisc_run(txq);
1738                         spin_unlock(&txq->lock);
1739
1740                         rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
1741                         goto out;
1742                 }
1743                 spin_unlock(&txq->lock);
1744         }
1745
1746         /* The device has no queue. Common case for software devices:
1747            loopback, all the sorts of tunnels...
1748
1749            Really, it is unlikely that netif_tx_lock protection is necessary
1750            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
1751            counters.)
1752            However, it is possible, that they rely on protection
1753            made by us here.
1754
1755            Check this and shot the lock. It is not prone from deadlocks.
1756            Either shot noqueue qdisc, it is even simpler 8)
1757          */
1758         if (dev->flags & IFF_UP) {
1759                 int cpu = smp_processor_id(); /* ok because BHs are off */
1760
1761                 if (txq->xmit_lock_owner != cpu) {
1762
1763                         HARD_TX_LOCK(dev, txq, cpu);
1764
1765                         if (!netif_queue_stopped(dev) &&
1766                             !netif_subqueue_stopped(dev, skb)) {
1767                                 rc = 0;
1768                                 if (!dev_hard_start_xmit(skb, dev)) {
1769                                         HARD_TX_UNLOCK(dev, txq);
1770                                         goto out;
1771                                 }
1772                         }
1773                         HARD_TX_UNLOCK(dev, txq);
1774                         if (net_ratelimit())
1775                                 printk(KERN_CRIT "Virtual device %s asks to "
1776                                        "queue packet!\n", dev->name);
1777                 } else {
1778                         /* Recursion is detected! It is possible,
1779                          * unfortunately */
1780                         if (net_ratelimit())
1781                                 printk(KERN_CRIT "Dead loop on virtual device "
1782                                        "%s, fix it urgently!\n", dev->name);
1783                 }
1784         }
1785
1786         rc = -ENETDOWN;
1787         rcu_read_unlock_bh();
1788
1789 out_kfree_skb:
1790         kfree_skb(skb);
1791         return rc;
1792 out:
1793         rcu_read_unlock_bh();
1794         return rc;
1795 }
1796
1797
1798 /*=======================================================================
1799                         Receiver routines
1800   =======================================================================*/
1801
1802 int netdev_max_backlog __read_mostly = 1000;
1803 int netdev_budget __read_mostly = 300;
1804 int weight_p __read_mostly = 64;            /* old backlog weight */
1805
1806 DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1807
1808
1809 /**
1810  *      netif_rx        -       post buffer to the network code
1811  *      @skb: buffer to post
1812  *
1813  *      This function receives a packet from a device driver and queues it for
1814  *      the upper (protocol) levels to process.  It always succeeds. The buffer
1815  *      may be dropped during processing for congestion control or by the
1816  *      protocol layers.
1817  *
1818  *      return values:
1819  *      NET_RX_SUCCESS  (no congestion)
1820  *      NET_RX_DROP     (packet was dropped)
1821  *
1822  */
1823
1824 int netif_rx(struct sk_buff *skb)
1825 {
1826         struct softnet_data *queue;
1827         unsigned long flags;
1828
1829         /* if netpoll wants it, pretend we never saw it */
1830         if (netpoll_rx(skb))
1831                 return NET_RX_DROP;
1832
1833         if (!skb->tstamp.tv64)
1834                 net_timestamp(skb);
1835
1836         /*
1837          * The code is rearranged so that the path is the most
1838          * short when CPU is congested, but is still operating.
1839          */
1840         local_irq_save(flags);
1841         queue = &__get_cpu_var(softnet_data);
1842
1843         __get_cpu_var(netdev_rx_stat).total++;
1844         if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1845                 if (queue->input_pkt_queue.qlen) {
1846 enqueue:
1847                         dev_hold(skb->dev);
1848                         __skb_queue_tail(&queue->input_pkt_queue, skb);
1849                         local_irq_restore(flags);
1850                         return NET_RX_SUCCESS;
1851                 }
1852
1853                 napi_schedule(&queue->backlog);
1854                 goto enqueue;
1855         }
1856
1857         __get_cpu_var(netdev_rx_stat).dropped++;
1858         local_irq_restore(flags);
1859
1860         kfree_skb(skb);
1861         return NET_RX_DROP;
1862 }
1863
1864 int netif_rx_ni(struct sk_buff *skb)
1865 {
1866         int err;
1867
1868         preempt_disable();
1869         err = netif_rx(skb);
1870         if (local_softirq_pending())
1871                 do_softirq();
1872         preempt_enable();
1873
1874         return err;
1875 }
1876
1877 EXPORT_SYMBOL(netif_rx_ni);
1878
1879 static inline struct net_device *skb_bond(struct sk_buff *skb)
1880 {
1881         struct net_device *dev = skb->dev;
1882
1883         if (dev->master) {
1884                 if (skb_bond_should_drop(skb)) {
1885                         kfree_skb(skb);
1886                         return NULL;
1887                 }
1888                 skb->dev = dev->master;
1889         }
1890
1891         return dev;
1892 }
1893
1894
1895 static void net_tx_action(struct softirq_action *h)
1896 {
1897         struct softnet_data *sd = &__get_cpu_var(softnet_data);
1898
1899         if (sd->completion_queue) {
1900                 struct sk_buff *clist;
1901
1902                 local_irq_disable();
1903                 clist = sd->completion_queue;
1904                 sd->completion_queue = NULL;
1905                 local_irq_enable();
1906
1907                 while (clist) {
1908                         struct sk_buff *skb = clist;
1909                         clist = clist->next;
1910
1911                         BUG_TRAP(!atomic_read(&skb->users));
1912                         __kfree_skb(skb);
1913                 }
1914         }
1915
1916         if (sd->output_queue) {
1917                 struct netdev_queue *head;
1918
1919                 local_irq_disable();
1920                 head = sd->output_queue;
1921                 sd->output_queue = NULL;
1922                 local_irq_enable();
1923
1924                 while (head) {
1925                         struct netdev_queue *txq = head;
1926                         struct net_device *dev = txq->dev;
1927                         head = head->next_sched;
1928
1929                         smp_mb__before_clear_bit();
1930                         clear_bit(__LINK_STATE_SCHED, &dev->state);
1931
1932                         if (spin_trylock(&txq->lock)) {
1933                                 qdisc_run(txq);
1934                                 spin_unlock(&txq->lock);
1935                         } else {
1936                                 netif_schedule_queue(txq);
1937                         }
1938                 }
1939         }
1940 }
1941
1942 static inline int deliver_skb(struct sk_buff *skb,
1943                               struct packet_type *pt_prev,
1944                               struct net_device *orig_dev)
1945 {
1946         atomic_inc(&skb->users);
1947         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1948 }
1949
1950 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
1951 /* These hooks defined here for ATM */
1952 struct net_bridge;
1953 struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
1954                                                 unsigned char *addr);
1955 void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
1956
1957 /*
1958  * If bridge module is loaded call bridging hook.
1959  *  returns NULL if packet was consumed.
1960  */
1961 struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
1962                                         struct sk_buff *skb) __read_mostly;
1963 static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
1964                                             struct packet_type **pt_prev, int *ret,
1965                                             struct net_device *orig_dev)
1966 {
1967         struct net_bridge_port *port;
1968
1969         if (skb->pkt_type == PACKET_LOOPBACK ||
1970             (port = rcu_dereference(skb->dev->br_port)) == NULL)
1971                 return skb;
1972
1973         if (*pt_prev) {
1974                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
1975                 *pt_prev = NULL;
1976         }
1977
1978         return br_handle_frame_hook(port, skb);
1979 }
1980 #else
1981 #define handle_bridge(skb, pt_prev, ret, orig_dev)      (skb)
1982 #endif
1983
1984 #if defined(CONFIG_MACVLAN) || defined(CONFIG_MACVLAN_MODULE)
1985 struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *skb) __read_mostly;
1986 EXPORT_SYMBOL_GPL(macvlan_handle_frame_hook);
1987
1988 static inline struct sk_buff *handle_macvlan(struct sk_buff *skb,
1989                                              struct packet_type **pt_prev,
1990                                              int *ret,
1991                                              struct net_device *orig_dev)
1992 {
1993         if (skb->dev->macvlan_port == NULL)
1994                 return skb;
1995
1996         if (*pt_prev) {
1997                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
1998                 *pt_prev = NULL;
1999         }
2000         return macvlan_handle_frame_hook(skb);
2001 }
2002 #else
2003 #define handle_macvlan(skb, pt_prev, ret, orig_dev)     (skb)
2004 #endif
2005
2006 #ifdef CONFIG_NET_CLS_ACT
2007 /* TODO: Maybe we should just force sch_ingress to be compiled in
2008  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
2009  * a compare and 2 stores extra right now if we dont have it on
2010  * but have CONFIG_NET_CLS_ACT
2011  * NOTE: This doesnt stop any functionality; if you dont have
2012  * the ingress scheduler, you just cant add policies on ingress.
2013  *
2014  */
2015 static int ing_filter(struct sk_buff *skb)
2016 {
2017         struct net_device *dev = skb->dev;
2018         u32 ttl = G_TC_RTTL(skb->tc_verd);
2019         struct netdev_queue *rxq;
2020         int result = TC_ACT_OK;
2021         struct Qdisc *q;
2022
2023         if (MAX_RED_LOOP < ttl++) {
2024                 printk(KERN_WARNING
2025                        "Redir loop detected Dropping packet (%d->%d)\n",
2026                        skb->iif, dev->ifindex);
2027                 return TC_ACT_SHOT;
2028         }
2029
2030         skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
2031         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
2032
2033         rxq = &dev->rx_queue;
2034
2035         spin_lock(&rxq->lock);
2036         if ((q = rxq->qdisc) != NULL)
2037                 result = q->enqueue(skb, q);
2038         spin_unlock(&rxq->lock);
2039
2040         return result;
2041 }
2042
2043 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
2044                                          struct packet_type **pt_prev,
2045                                          int *ret, struct net_device *orig_dev)
2046 {
2047         if (!skb->dev->rx_queue.qdisc)
2048                 goto out;
2049
2050         if (*pt_prev) {
2051                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2052                 *pt_prev = NULL;
2053         } else {
2054                 /* Huh? Why does turning on AF_PACKET affect this? */
2055                 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
2056         }
2057
2058         switch (ing_filter(skb)) {
2059         case TC_ACT_SHOT:
2060         case TC_ACT_STOLEN:
2061                 kfree_skb(skb);
2062                 return NULL;
2063         }
2064
2065 out:
2066         skb->tc_verd = 0;
2067         return skb;
2068 }
2069 #endif
2070
2071 /*
2072  *      netif_nit_deliver - deliver received packets to network taps
2073  *      @skb: buffer
2074  *
2075  *      This function is used to deliver incoming packets to network
2076  *      taps. It should be used when the normal netif_receive_skb path
2077  *      is bypassed, for example because of VLAN acceleration.
2078  */
2079 void netif_nit_deliver(struct sk_buff *skb)
2080 {
2081         struct packet_type *ptype;
2082
2083         if (list_empty(&ptype_all))
2084                 return;
2085
2086         skb_reset_network_header(skb);
2087         skb_reset_transport_header(skb);
2088         skb->mac_len = skb->network_header - skb->mac_header;
2089
2090         rcu_read_lock();
2091         list_for_each_entry_rcu(ptype, &ptype_all, list) {
2092                 if (!ptype->dev || ptype->dev == skb->dev)
2093                         deliver_skb(skb, ptype, skb->dev);
2094         }
2095         rcu_read_unlock();
2096 }
2097
2098 /**
2099  *      netif_receive_skb - process receive buffer from network
2100  *      @skb: buffer to process
2101  *
2102  *      netif_receive_skb() is the main receive data processing function.
2103  *      It always succeeds. The buffer may be dropped during processing
2104  *      for congestion control or by the protocol layers.
2105  *
2106  *      This function may only be called from softirq context and interrupts
2107  *      should be enabled.
2108  *
2109  *      Return values (usually ignored):
2110  *      NET_RX_SUCCESS: no congestion
2111  *      NET_RX_DROP: packet was dropped
2112  */
2113 int netif_receive_skb(struct sk_buff *skb)
2114 {
2115         struct packet_type *ptype, *pt_prev;
2116         struct net_device *orig_dev;
2117         int ret = NET_RX_DROP;
2118         __be16 type;
2119
2120         /* if we've gotten here through NAPI, check netpoll */
2121         if (netpoll_receive_skb(skb))
2122                 return NET_RX_DROP;
2123
2124         if (!skb->tstamp.tv64)
2125                 net_timestamp(skb);
2126
2127         if (!skb->iif)
2128                 skb->iif = skb->dev->ifindex;
2129
2130         orig_dev = skb_bond(skb);
2131
2132         if (!orig_dev)
2133                 return NET_RX_DROP;
2134
2135         __get_cpu_var(netdev_rx_stat).total++;
2136
2137         skb_reset_network_header(skb);
2138         skb_reset_transport_header(skb);
2139         skb->mac_len = skb->network_header - skb->mac_header;
2140
2141         pt_prev = NULL;
2142
2143         rcu_read_lock();
2144
2145         /* Don't receive packets in an exiting network namespace */
2146         if (!net_alive(dev_net(skb->dev)))
2147                 goto out;
2148
2149 #ifdef CONFIG_NET_CLS_ACT
2150         if (skb->tc_verd & TC_NCLS) {
2151                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2152                 goto ncls;
2153         }
2154 #endif
2155
2156         list_for_each_entry_rcu(ptype, &ptype_all, list) {
2157                 if (!ptype->dev || ptype->dev == skb->dev) {
2158                         if (pt_prev)
2159                                 ret = deliver_skb(skb, pt_prev, orig_dev);
2160                         pt_prev = ptype;
2161                 }
2162         }
2163
2164 #ifdef CONFIG_NET_CLS_ACT
2165         skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2166         if (!skb)
2167                 goto out;
2168 ncls:
2169 #endif
2170
2171         skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
2172         if (!skb)
2173                 goto out;
2174         skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
2175         if (!skb)
2176                 goto out;
2177
2178         type = skb->protocol;
2179         list_for_each_entry_rcu(ptype,
2180                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
2181                 if (ptype->type == type &&
2182                     (!ptype->dev || ptype->dev == skb->dev)) {
2183                         if (pt_prev)
2184                                 ret = deliver_skb(skb, pt_prev, orig_dev);
2185                         pt_prev = ptype;
2186                 }
2187         }
2188
2189         if (pt_prev) {
2190                 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2191         } else {
2192                 kfree_skb(skb);
2193                 /* Jamal, now you will not able to escape explaining
2194                  * me how you were going to use this. :-)
2195                  */
2196                 ret = NET_RX_DROP;
2197         }
2198
2199 out:
2200         rcu_read_unlock();
2201         return ret;
2202 }
2203
2204 static int process_backlog(struct napi_struct *napi, int quota)
2205 {
2206         int work = 0;
2207         struct softnet_data *queue = &__get_cpu_var(softnet_data);
2208         unsigned long start_time = jiffies;
2209
2210         napi->weight = weight_p;
2211         do {
2212                 struct sk_buff *skb;
2213                 struct net_device *dev;
2214
2215                 local_irq_disable();
2216                 skb = __skb_dequeue(&queue->input_pkt_queue);
2217                 if (!skb) {
2218                         __napi_complete(napi);
2219                         local_irq_enable();
2220                         break;
2221                 }
2222
2223                 local_irq_enable();
2224
2225                 dev = skb->dev;
2226
2227                 netif_receive_skb(skb);
2228
2229                 dev_put(dev);
2230         } while (++work < quota && jiffies == start_time);
2231
2232         return work;
2233 }
2234
2235 /**
2236  * __napi_schedule - schedule for receive
2237  * @n: entry to schedule
2238  *
2239  * The entry's receive function will be scheduled to run
2240  */
2241 void __napi_schedule(struct napi_struct *n)
2242 {
2243         unsigned long flags;
2244
2245         local_irq_save(flags);
2246         list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
2247         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2248         local_irq_restore(flags);
2249 }
2250 EXPORT_SYMBOL(__napi_schedule);
2251
2252
2253 static void net_rx_action(struct softirq_action *h)
2254 {
2255         struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
2256         unsigned long start_time = jiffies;
2257         int budget = netdev_budget;
2258         void *have;
2259
2260         local_irq_disable();
2261
2262         while (!list_empty(list)) {
2263                 struct napi_struct *n;
2264                 int work, weight;
2265
2266                 /* If softirq window is exhuasted then punt.
2267                  *
2268                  * Note that this is a slight policy change from the
2269                  * previous NAPI code, which would allow up to 2
2270                  * jiffies to pass before breaking out.  The test
2271                  * used to be "jiffies - start_time > 1".
2272                  */
2273                 if (unlikely(budget <= 0 || jiffies != start_time))
2274                         goto softnet_break;
2275
2276                 local_irq_enable();
2277
2278                 /* Even though interrupts have been re-enabled, this
2279                  * access is safe because interrupts can only add new
2280                  * entries to the tail of this list, and only ->poll()
2281                  * calls can remove this head entry from the list.
2282                  */
2283                 n = list_entry(list->next, struct napi_struct, poll_list);
2284
2285                 have = netpoll_poll_lock(n);
2286
2287                 weight = n->weight;
2288
2289                 /* This NAPI_STATE_SCHED test is for avoiding a race
2290                  * with netpoll's poll_napi().  Only the entity which
2291                  * obtains the lock and sees NAPI_STATE_SCHED set will
2292                  * actually make the ->poll() call.  Therefore we avoid
2293                  * accidently calling ->poll() when NAPI is not scheduled.
2294                  */
2295                 work = 0;
2296                 if (test_bit(NAPI_STATE_SCHED, &n->state))
2297                         work = n->poll(n, weight);
2298
2299                 WARN_ON_ONCE(work > weight);
2300
2301                 budget -= work;
2302
2303                 local_irq_disable();
2304
2305                 /* Drivers must not modify the NAPI state if they
2306                  * consume the entire weight.  In such cases this code
2307                  * still "owns" the NAPI instance and therefore can
2308                  * move the instance around on the list at-will.
2309                  */
2310                 if (unlikely(work == weight)) {
2311                         if (unlikely(napi_disable_pending(n)))
2312                                 __napi_complete(n);
2313                         else
2314                                 list_move_tail(&n->poll_list, list);
2315                 }
2316
2317                 netpoll_poll_unlock(have);
2318         }
2319 out:
2320         local_irq_enable();
2321
2322 #ifdef CONFIG_NET_DMA
2323         /*
2324          * There may not be any more sk_buffs coming right now, so push
2325          * any pending DMA copies to hardware
2326          */
2327         if (!cpus_empty(net_dma.channel_mask)) {
2328                 int chan_idx;
2329                 for_each_cpu_mask(chan_idx, net_dma.channel_mask) {
2330                         struct dma_chan *chan = net_dma.channels[chan_idx];
2331                         if (chan)
2332                                 dma_async_memcpy_issue_pending(chan);
2333                 }
2334         }
2335 #endif
2336
2337         return;
2338
2339 softnet_break:
2340         __get_cpu_var(netdev_rx_stat).time_squeeze++;
2341         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2342         goto out;
2343 }
2344
2345 static gifconf_func_t * gifconf_list [NPROTO];
2346
2347 /**
2348  *      register_gifconf        -       register a SIOCGIF handler
2349  *      @family: Address family
2350  *      @gifconf: Function handler
2351  *
2352  *      Register protocol dependent address dumping routines. The handler
2353  *      that is passed must not be freed or reused until it has been replaced
2354  *      by another handler.
2355  */
2356 int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
2357 {
2358         if (family >= NPROTO)
2359                 return -EINVAL;
2360         gifconf_list[family] = gifconf;
2361         return 0;
2362 }
2363
2364
2365 /*
2366  *      Map an interface index to its name (SIOCGIFNAME)
2367  */
2368
2369 /*
2370  *      We need this ioctl for efficient implementation of the
2371  *      if_indextoname() function required by the IPv6 API.  Without
2372  *      it, we would have to search all the interfaces to find a
2373  *      match.  --pb
2374  */
2375
2376 static int dev_ifname(struct net *net, struct ifreq __user *arg)
2377 {
2378         struct net_device *dev;
2379         struct ifreq ifr;
2380
2381         /*
2382          *      Fetch the caller's info block.
2383          */
2384
2385         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2386                 return -EFAULT;
2387
2388         read_lock(&dev_base_lock);
2389         dev = __dev_get_by_index(net, ifr.ifr_ifindex);
2390         if (!dev) {
2391                 read_unlock(&dev_base_lock);
2392                 return -ENODEV;
2393         }
2394
2395         strcpy(ifr.ifr_name, dev->name);
2396         read_unlock(&dev_base_lock);
2397
2398         if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2399                 return -EFAULT;
2400         return 0;
2401 }
2402
2403 /*
2404  *      Perform a SIOCGIFCONF call. This structure will change
2405  *      size eventually, and there is nothing I can do about it.
2406  *      Thus we will need a 'compatibility mode'.
2407  */
2408
2409 static int dev_ifconf(struct net *net, char __user *arg)
2410 {
2411         struct ifconf ifc;
2412         struct net_device *dev;
2413         char __user *pos;
2414         int len;
2415         int total;
2416         int i;
2417
2418         /*
2419          *      Fetch the caller's info block.
2420          */
2421
2422         if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2423                 return -EFAULT;
2424
2425         pos = ifc.ifc_buf;
2426         len = ifc.ifc_len;
2427
2428         /*
2429          *      Loop over the interfaces, and write an info block for each.
2430          */
2431
2432         total = 0;
2433         for_each_netdev(net, dev) {
2434                 for (i = 0; i < NPROTO; i++) {
2435                         if (gifconf_list[i]) {
2436                                 int done;
2437                                 if (!pos)
2438                                         done = gifconf_list[i](dev, NULL, 0);
2439                                 else
2440                                         done = gifconf_list[i](dev, pos + total,
2441                                                                len - total);
2442                                 if (done < 0)
2443                                         return -EFAULT;
2444                                 total += done;
2445                         }
2446                 }
2447         }
2448
2449         /*
2450          *      All done.  Write the updated control block back to the caller.
2451          */
2452         ifc.ifc_len = total;
2453
2454         /*
2455          *      Both BSD and Solaris return 0 here, so we do too.
2456          */
2457         return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2458 }
2459
2460 #ifdef CONFIG_PROC_FS
2461 /*
2462  *      This is invoked by the /proc filesystem handler to display a device
2463  *      in detail.
2464  */
2465 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2466         __acquires(dev_base_lock)
2467 {
2468         struct net *net = seq_file_net(seq);
2469         loff_t off;
2470         struct net_device *dev;
2471
2472         read_lock(&dev_base_lock);
2473         if (!*pos)
2474                 return SEQ_START_TOKEN;
2475
2476         off = 1;
2477         for_each_netdev(net, dev)
2478                 if (off++ == *pos)
2479                         return dev;
2480
2481         return NULL;
2482 }
2483
2484 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2485 {
2486         struct net *net = seq_file_net(seq);
2487         ++*pos;
2488         return v == SEQ_START_TOKEN ?
2489                 first_net_device(net) : next_net_device((struct net_device *)v);
2490 }
2491
2492 void dev_seq_stop(struct seq_file *seq, void *v)
2493         __releases(dev_base_lock)
2494 {
2495         read_unlock(&dev_base_lock);
2496 }
2497
2498 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2499 {
2500         struct net_device_stats *stats = dev->get_stats(dev);
2501
2502         seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2503                    "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2504                    dev->name, stats->rx_bytes, stats->rx_packets,
2505                    stats->rx_errors,
2506                    stats->rx_dropped + stats->rx_missed_errors,
2507                    stats->rx_fifo_errors,
2508                    stats->rx_length_errors + stats->rx_over_errors +
2509                     stats->rx_crc_errors + stats->rx_frame_errors,
2510                    stats->rx_compressed, stats->multicast,
2511                    stats->tx_bytes, stats->tx_packets,
2512                    stats->tx_errors, stats->tx_dropped,
2513                    stats->tx_fifo_errors, stats->collisions,
2514                    stats->tx_carrier_errors +
2515                     stats->tx_aborted_errors +
2516                     stats->tx_window_errors +
2517                     stats->tx_heartbeat_errors,
2518                    stats->tx_compressed);
2519 }
2520
2521 /*
2522  *      Called from the PROCfs module. This now uses the new arbitrary sized
2523  *      /proc/net interface to create /proc/net/dev
2524  */
2525 static int dev_seq_show(struct seq_file *seq, void *v)
2526 {
2527         if (v == SEQ_START_TOKEN)
2528                 seq_puts(seq, "Inter-|   Receive                            "
2529                               "                    |  Transmit\n"
2530                               " face |bytes    packets errs drop fifo frame "
2531                               "compressed multicast|bytes    packets errs "
2532                               "drop fifo colls carrier compressed\n");
2533         else
2534                 dev_seq_printf_stats(seq, v);
2535         return 0;
2536 }
2537
2538 static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2539 {
2540         struct netif_rx_stats *rc = NULL;
2541
2542         while (*pos < nr_cpu_ids)
2543                 if (cpu_online(*pos)) {
2544                         rc = &per_cpu(netdev_rx_stat, *pos);
2545                         break;
2546                 } else
2547                         ++*pos;
2548         return rc;
2549 }
2550
2551 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2552 {
2553         return softnet_get_online(pos);
2554 }
2555
2556 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2557 {
2558         ++*pos;
2559         return softnet_get_online(pos);
2560 }
2561
2562 static void softnet_seq_stop(struct seq_file *seq, void *v)
2563 {
2564 }
2565
2566 static int softnet_seq_show(struct seq_file *seq, void *v)
2567 {
2568         struct netif_rx_stats *s = v;
2569
2570         seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
2571                    s->total, s->dropped, s->time_squeeze, 0,
2572                    0, 0, 0, 0, /* was fastroute */
2573                    s->cpu_collision );
2574         return 0;
2575 }
2576
2577 static const struct seq_operations dev_seq_ops = {
2578         .start = dev_seq_start,
2579         .next  = dev_seq_next,
2580         .stop  = dev_seq_stop,
2581         .show  = dev_seq_show,
2582 };
2583
2584 static int dev_seq_open(struct inode *inode, struct file *file)
2585 {
2586         return seq_open_net(inode, file, &dev_seq_ops,
2587                             sizeof(struct seq_net_private));
2588 }
2589
2590 static const struct file_operations dev_seq_fops = {
2591         .owner   = THIS_MODULE,
2592         .open    = dev_seq_open,
2593         .read    = seq_read,
2594         .llseek  = seq_lseek,
2595         .release = seq_release_net,
2596 };
2597
2598 static const struct seq_operations softnet_seq_ops = {
2599         .start = softnet_seq_start,
2600         .next  = softnet_seq_next,
2601         .stop  = softnet_seq_stop,
2602         .show  = softnet_seq_show,
2603 };
2604
2605 static int softnet_seq_open(struct inode *inode, struct file *file)
2606 {
2607         return seq_open(file, &softnet_seq_ops);
2608 }
2609
2610 static const struct file_operations softnet_seq_fops = {
2611         .owner   = THIS_MODULE,
2612         .open    = softnet_seq_open,
2613         .read    = seq_read,
2614         .llseek  = seq_lseek,
2615         .release = seq_release,
2616 };
2617
2618 static void *ptype_get_idx(loff_t pos)
2619 {
2620         struct packet_type *pt = NULL;
2621         loff_t i = 0;
2622         int t;
2623
2624         list_for_each_entry_rcu(pt, &ptype_all, list) {
2625                 if (i == pos)
2626                         return pt;
2627                 ++i;
2628         }
2629
2630         for (t = 0; t < PTYPE_HASH_SIZE; t++) {
2631                 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
2632                         if (i == pos)
2633                                 return pt;
2634                         ++i;
2635                 }
2636         }
2637         return NULL;
2638 }
2639
2640 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
2641         __acquires(RCU)
2642 {
2643         rcu_read_lock();
2644         return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
2645 }
2646
2647 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2648 {
2649         struct packet_type *pt;
2650         struct list_head *nxt;
2651         int hash;
2652
2653         ++*pos;
2654         if (v == SEQ_START_TOKEN)
2655                 return ptype_get_idx(0);
2656
2657         pt = v;
2658         nxt = pt->list.next;
2659         if (pt->type == htons(ETH_P_ALL)) {
2660                 if (nxt != &ptype_all)
2661                         goto found;
2662                 hash = 0;
2663                 nxt = ptype_base[0].next;
2664         } else
2665                 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
2666
2667         while (nxt == &ptype_base[hash]) {
2668                 if (++hash >= PTYPE_HASH_SIZE)
2669                         return NULL;
2670                 nxt = ptype_base[hash].next;
2671         }
2672 found:
2673         return list_entry(nxt, struct packet_type, list);
2674 }
2675
2676 static void ptype_seq_stop(struct seq_file *seq, void *v)
2677         __releases(RCU)
2678 {
2679         rcu_read_unlock();
2680 }
2681
2682 static void ptype_seq_decode(struct seq_file *seq, void *sym)
2683 {
2684 #ifdef CONFIG_KALLSYMS
2685         unsigned long offset = 0, symsize;
2686         const char *symname;
2687         char *modname;
2688         char namebuf[128];
2689
2690         symname = kallsyms_lookup((unsigned long)sym, &symsize, &offset,
2691                                   &modname, namebuf);
2692
2693         if (symname) {
2694                 char *delim = ":";
2695
2696                 if (!modname)
2697                         modname = delim = "";
2698                 seq_printf(seq, "%s%s%s%s+0x%lx", delim, modname, delim,
2699                            symname, offset);
2700                 return;
2701         }
2702 #endif
2703
2704         seq_printf(seq, "[%p]", sym);
2705 }
2706
2707 static int ptype_seq_show(struct seq_file *seq, void *v)
2708 {
2709         struct packet_type *pt = v;
2710
2711         if (v == SEQ_START_TOKEN)
2712                 seq_puts(seq, "Type Device      Function\n");
2713         else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
2714                 if (pt->type == htons(ETH_P_ALL))
2715                         seq_puts(seq, "ALL ");
2716                 else
2717                         seq_printf(seq, "%04x", ntohs(pt->type));
2718
2719                 seq_printf(seq, " %-8s ",
2720                            pt->dev ? pt->dev->name : "");
2721                 ptype_seq_decode(seq,  pt->func);
2722                 seq_putc(seq, '\n');
2723         }
2724
2725         return 0;
2726 }
2727
2728 static const struct seq_operations ptype_seq_ops = {
2729         .start = ptype_seq_start,
2730         .next  = ptype_seq_next,
2731         .stop  = ptype_seq_stop,
2732         .show  = ptype_seq_show,
2733 };
2734
2735 static int ptype_seq_open(struct inode *inode, struct file *file)
2736 {
2737         return seq_open_net(inode, file, &ptype_seq_ops,
2738                         sizeof(struct seq_net_private));
2739 }
2740
2741 static const struct file_operations ptype_seq_fops = {
2742         .owner   = THIS_MODULE,
2743         .open    = ptype_seq_open,
2744         .read    = seq_read,
2745         .llseek  = seq_lseek,
2746         .release = seq_release_net,
2747 };
2748
2749
2750 static int __net_init dev_proc_net_init(struct net *net)
2751 {
2752         int rc = -ENOMEM;
2753
2754         if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
2755                 goto out;
2756         if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
2757                 goto out_dev;
2758         if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
2759                 goto out_softnet;
2760
2761         if (wext_proc_init(net))
2762                 goto out_ptype;
2763         rc = 0;
2764 out:
2765         return rc;
2766 out_ptype:
2767         proc_net_remove(net, "ptype");
2768 out_softnet:
2769         proc_net_remove(net, "softnet_stat");
2770 out_dev:
2771         proc_net_remove(net, "dev");
2772         goto out;
2773 }
2774
2775 static void __net_exit dev_proc_net_exit(struct net *net)
2776 {
2777         wext_proc_exit(net);
2778
2779         proc_net_remove(net, "ptype");
2780         proc_net_remove(net, "softnet_stat");
2781         proc_net_remove(net, "dev");
2782 }
2783
2784 static struct pernet_operations __net_initdata dev_proc_ops = {
2785         .init = dev_proc_net_init,
2786         .exit = dev_proc_net_exit,
2787 };
2788
2789 static int __init dev_proc_init(void)
2790 {
2791         return register_pernet_subsys(&dev_proc_ops);
2792 }
2793 #else
2794 #define dev_proc_init() 0
2795 #endif  /* CONFIG_PROC_FS */
2796
2797
2798 /**
2799  *      netdev_set_master       -       set up master/slave pair
2800  *      @slave: slave device
2801  *      @master: new master device
2802  *
2803  *      Changes the master device of the slave. Pass %NULL to break the
2804  *      bonding. The caller must hold the RTNL semaphore. On a failure
2805  *      a negative errno code is returned. On success the reference counts
2806  *      are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2807  *      function returns zero.
2808  */
2809 int netdev_set_master(struct net_device *slave, struct net_device *master)
2810 {
2811         struct net_device *old = slave->master;
2812
2813         ASSERT_RTNL();
2814
2815         if (master) {
2816                 if (old)
2817                         return -EBUSY;
2818                 dev_hold(master);
2819         }
2820
2821         slave->master = master;
2822
2823         synchronize_net();
2824
2825         if (old)
2826                 dev_put(old);
2827
2828         if (master)
2829                 slave->flags |= IFF_SLAVE;
2830         else
2831                 slave->flags &= ~IFF_SLAVE;
2832
2833         rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2834         return 0;
2835 }
2836
2837 static int __dev_set_promiscuity(struct net_device *dev, int inc)
2838 {
2839         unsigned short old_flags = dev->flags;
2840
2841         ASSERT_RTNL();
2842
2843         dev->flags |= IFF_PROMISC;
2844         dev->promiscuity += inc;
2845         if (dev->promiscuity == 0) {
2846                 /*
2847                  * Avoid overflow.
2848                  * If inc causes overflow, untouch promisc and return error.
2849                  */
2850                 if (inc < 0)
2851                         dev->flags &= ~IFF_PROMISC;
2852                 else {
2853                         dev->promiscuity -= inc;
2854                         printk(KERN_WARNING "%s: promiscuity touches roof, "
2855                                 "set promiscuity failed, promiscuity feature "
2856                                 "of device might be broken.\n", dev->name);
2857                         return -EOVERFLOW;
2858                 }
2859         }
2860         if (dev->flags != old_flags) {
2861                 printk(KERN_INFO "device %s %s promiscuous mode\n",
2862                        dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
2863                                                                "left");
2864                 if (audit_enabled)
2865                         audit_log(current->audit_context, GFP_ATOMIC,
2866                                 AUDIT_ANOM_PROMISCUOUS,
2867                                 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
2868                                 dev->name, (dev->flags & IFF_PROMISC),
2869                                 (old_flags & IFF_PROMISC),
2870                                 audit_get_loginuid(current),
2871                                 current->uid, current->gid,
2872                                 audit_get_sessionid(current));
2873
2874                 if (dev->change_rx_flags)
2875                         dev->change_rx_flags(dev, IFF_PROMISC);
2876         }
2877         return 0;
2878 }
2879
2880 /**
2881  *      dev_set_promiscuity     - update promiscuity count on a device
2882  *      @dev: device
2883  *      @inc: modifier
2884  *
2885  *      Add or remove promiscuity from a device. While the count in the device
2886  *      remains above zero the interface remains promiscuous. Once it hits zero
2887  *      the device reverts back to normal filtering operation. A negative inc
2888  *      value is used to drop promiscuity on the device.
2889  *      Return 0 if successful or a negative errno code on error.
2890  */
2891 int dev_set_promiscuity(struct net_device *dev, int inc)
2892 {
2893         unsigned short old_flags = dev->flags;
2894         int err;
2895
2896         err = __dev_set_promiscuity(dev, inc);
2897         if (err < 0)
2898                 return err;
2899         if (dev->flags != old_flags)
2900                 dev_set_rx_mode(dev);
2901         return err;
2902 }
2903
2904 /**
2905  *      dev_set_allmulti        - update allmulti count on a device
2906  *      @dev: device
2907  *      @inc: modifier
2908  *
2909  *      Add or remove reception of all multicast frames to a device. While the
2910  *      count in the device remains above zero the interface remains listening
2911  *      to all interfaces. Once it hits zero the device reverts back to normal
2912  *      filtering operation. A negative @inc value is used to drop the counter
2913  *      when releasing a resource needing all multicasts.
2914  *      Return 0 if successful or a negative errno code on error.
2915  */
2916
2917 int dev_set_allmulti(struct net_device *dev, int inc)
2918 {
2919         unsigned short old_flags = dev->flags;
2920
2921         ASSERT_RTNL();
2922
2923         dev->flags |= IFF_ALLMULTI;
2924         dev->allmulti += inc;
2925         if (dev->allmulti == 0) {
2926                 /*
2927                  * Avoid overflow.
2928                  * If inc causes overflow, untouch allmulti and return error.
2929                  */
2930                 if (inc < 0)
2931                         dev->flags &= ~IFF_ALLMULTI;
2932                 else {
2933                         dev->allmulti -= inc;
2934                         printk(KERN_WARNING "%s: allmulti touches roof, "
2935                                 "set allmulti failed, allmulti feature of "
2936                                 "device might be broken.\n", dev->name);
2937                         return -EOVERFLOW;
2938                 }
2939         }
2940         if (dev->flags ^ old_flags) {
2941                 if (dev->change_rx_flags)
2942                         dev->change_rx_flags(dev, IFF_ALLMULTI);
2943                 dev_set_rx_mode(dev);
2944         }
2945         return 0;
2946 }
2947
2948 /*
2949  *      Upload unicast and multicast address lists to device and
2950  *      configure RX filtering. When the device doesn't support unicast
2951  *      filtering it is put in promiscuous mode while unicast addresses
2952  *      are present.
2953  */
2954 void __dev_set_rx_mode(struct net_device *dev)
2955 {
2956         /* dev_open will call this function so the list will stay sane. */
2957         if (!(dev->flags&IFF_UP))
2958                 return;
2959
2960         if (!netif_device_present(dev))
2961                 return;
2962
2963         if (dev->set_rx_mode)
2964                 dev->set_rx_mode(dev);
2965         else {
2966                 /* Unicast addresses changes may only happen under the rtnl,
2967                  * therefore calling __dev_set_promiscuity here is safe.
2968                  */
2969                 if (dev->uc_count > 0 && !dev->uc_promisc) {
2970                         __dev_set_promiscuity(dev, 1);
2971                         dev->uc_promisc = 1;
2972                 } else if (dev->uc_count == 0 && dev->uc_promisc) {
2973                         __dev_set_promiscuity(dev, -1);
2974                         dev->uc_promisc = 0;
2975                 }
2976
2977                 if (dev->set_multicast_list)
2978                         dev->set_multicast_list(dev);
2979         }
2980 }
2981
2982 void dev_set_rx_mode(struct net_device *dev)
2983 {
2984         netif_tx_lock_bh(dev);
2985         netif_addr_lock(dev);
2986         __dev_set_rx_mode(dev);
2987         netif_addr_unlock(dev);
2988         netif_tx_unlock_bh(dev);
2989 }
2990
2991 int __dev_addr_delete(struct dev_addr_list **list, int *count,
2992                       void *addr, int alen, int glbl)
2993 {
2994         struct dev_addr_list *da;
2995
2996         for (; (da = *list) != NULL; list = &da->next) {
2997                 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
2998                     alen == da->da_addrlen) {
2999                         if (glbl) {
3000                                 int old_glbl = da->da_gusers;
3001                                 da->da_gusers = 0;
3002                                 if (old_glbl == 0)
3003                                         break;
3004                         }
3005                         if (--da->da_users)
3006                                 return 0;
3007
3008                         *list = da->next;
3009                         kfree(da);
3010                         (*count)--;
3011                         return 0;
3012                 }
3013         }
3014         return -ENOENT;
3015 }
3016
3017 int __dev_addr_add(struct dev_addr_list **list, int *count,
3018                    void *addr, int alen, int glbl)
3019 {
3020         struct dev_addr_list *da;
3021
3022         for (da = *list; da != NULL; da = da->next) {
3023                 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3024                     da->da_addrlen == alen) {
3025                         if (glbl) {
3026                                 int old_glbl = da->da_gusers;
3027                                 da->da_gusers = 1;
3028                                 if (old_glbl)
3029                                         return 0;
3030                         }
3031                         da->da_users++;
3032                         return 0;
3033                 }
3034         }
3035
3036         da = kzalloc(sizeof(*da), GFP_ATOMIC);
3037         if (da == NULL)
3038                 return -ENOMEM;
3039         memcpy(da->da_addr, addr, alen);
3040         da->da_addrlen = alen;
3041         da->da_users = 1;
3042         da->da_gusers = glbl ? 1 : 0;
3043         da->next = *list;
3044         *list = da;
3045         (*count)++;
3046         return 0;
3047 }
3048
3049 /**
3050  *      dev_unicast_delete      - Release secondary unicast address.
3051  *      @dev: device
3052  *      @addr: address to delete
3053  *      @alen: length of @addr
3054  *
3055  *      Release reference to a secondary unicast address and remove it
3056  *      from the device if the reference count drops to zero.
3057  *
3058  *      The caller must hold the rtnl_mutex.
3059  */
3060 int dev_unicast_delete(struct net_device *dev, void *addr, int alen)
3061 {
3062         int err;
3063
3064         ASSERT_RTNL();
3065
3066         netif_tx_lock_bh(dev);
3067         netif_addr_lock(dev);
3068         err = __dev_addr_delete(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3069         if (!err)
3070                 __dev_set_rx_mode(dev);
3071         netif_addr_unlock(dev);
3072         netif_tx_unlock_bh(dev);
3073         return err;
3074 }
3075 EXPORT_SYMBOL(dev_unicast_delete);
3076
3077 /**
3078  *      dev_unicast_add         - add a secondary unicast address
3079  *      @dev: device
3080  *      @addr: address to add
3081  *      @alen: length of @addr
3082  *
3083  *      Add a secondary unicast address to the device or increase
3084  *      the reference count if it already exists.
3085  *
3086  *      The caller must hold the rtnl_mutex.
3087  */
3088 int dev_unicast_add(struct net_device *dev, void *addr, int alen)
3089 {
3090         int err;
3091
3092         ASSERT_RTNL();
3093
3094         netif_tx_lock_bh(dev);
3095         netif_addr_lock(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(dev);
3100         netif_tx_unlock_bh(dev);
3101         return err;
3102 }
3103 EXPORT_SYMBOL(dev_unicast_add);
3104
3105 int __dev_addr_sync(struct dev_addr_list **to, int *to_count,
3106                     struct dev_addr_list **from, int *from_count)
3107 {
3108         struct dev_addr_list *da, *next;
3109         int err = 0;
3110
3111         da = *from;
3112         while (da != NULL) {
3113                 next = da->next;
3114                 if (!da->da_synced) {
3115                         err = __dev_addr_add(to, to_count,
3116                                              da->da_addr, da->da_addrlen, 0);
3117                         if (err < 0)
3118                                 break;
3119                         da->da_synced = 1;
3120                         da->da_users++;
3121                 } else if (da->da_users == 1) {
3122                         __dev_addr_delete(to, to_count,
3123                                           da->da_addr, da->da_addrlen, 0);
3124                         __dev_addr_delete(from, from_count,
3125                                           da->da_addr, da->da_addrlen, 0);
3126                 }
3127                 da = next;
3128         }
3129         return err;
3130 }
3131
3132 void __dev_addr_unsync(struct dev_addr_list **to, int *to_count,
3133                        struct dev_addr_list **from, int *from_count)
3134 {
3135         struct dev_addr_list *da, *next;
3136
3137         da = *from;
3138         while (da != NULL) {
3139                 next = da->next;
3140                 if (da->da_synced) {
3141                         __dev_addr_delete(to, to_count,
3142                                           da->da_addr, da->da_addrlen, 0);
3143                         da->da_synced = 0;
3144                         __dev_addr_delete(from, from_count,
3145                                           da->da_addr, da->da_addrlen, 0);
3146                 }
3147                 da = next;
3148         }
3149 }
3150
3151 /**
3152  *      dev_unicast_sync - Synchronize device's unicast list to another device
3153  *      @to: destination device
3154  *      @from: source device
3155  *
3156  *      Add newly added addresses to the destination device and release
3157  *      addresses that have no users left. The source device must be
3158  *      locked by netif_tx_lock_bh.
3159  *
3160  *      This function is intended to be called from the dev->set_rx_mode
3161  *      function of layered software devices.
3162  */
3163 int dev_unicast_sync(struct net_device *to, struct net_device *from)
3164 {
3165         int err = 0;
3166
3167         netif_tx_lock_bh(to);
3168         netif_addr_lock(to);
3169         err = __dev_addr_sync(&to->uc_list, &to->uc_count,
3170                               &from->uc_list, &from->uc_count);
3171         if (!err)
3172                 __dev_set_rx_mode(to);
3173         netif_addr_unlock(to);
3174         netif_tx_unlock_bh(to);
3175         return err;
3176 }
3177 EXPORT_SYMBOL(dev_unicast_sync);
3178
3179 /**
3180  *      dev_unicast_unsync - Remove synchronized addresses from the destination device
3181  *      @to: destination device
3182  *      @from: source device
3183  *
3184  *      Remove all addresses that were added to the destination device by
3185  *      dev_unicast_sync(). This function is intended to be called from the
3186  *      dev->stop function of layered software devices.
3187  */
3188 void dev_unicast_unsync(struct net_device *to, struct net_device *from)
3189 {
3190         netif_tx_lock_bh(from);
3191         netif_addr_lock(from);
3192         netif_tx_lock_bh(to);
3193         netif_addr_lock(to);
3194
3195         __dev_addr_unsync(&to->uc_list, &to->uc_count,
3196                           &from->uc_list, &from->uc_count);
3197         __dev_set_rx_mode(to);
3198
3199         netif_addr_unlock(to);
3200         netif_tx_unlock_bh(to);
3201         netif_addr_unlock(from);
3202         netif_tx_unlock_bh(from);
3203 }
3204 EXPORT_SYMBOL(dev_unicast_unsync);
3205
3206 static void __dev_addr_discard(struct dev_addr_list **list)
3207 {
3208         struct dev_addr_list *tmp;
3209
3210         while (*list != NULL) {
3211                 tmp = *list;
3212                 *list = tmp->next;
3213                 if (tmp->da_users > tmp->da_gusers)
3214                         printk("__dev_addr_discard: address leakage! "
3215                                "da_users=%d\n", tmp->da_users);
3216                 kfree(tmp);
3217         }
3218 }
3219
3220 static void dev_addr_discard(struct net_device *dev)
3221 {
3222         netif_tx_lock_bh(dev);
3223         netif_addr_lock(dev);
3224
3225         __dev_addr_discard(&dev->uc_list);
3226         dev->uc_count = 0;
3227
3228         __dev_addr_discard(&dev->mc_list);
3229         dev->mc_count = 0;
3230
3231         netif_addr_unlock(dev);
3232         netif_tx_unlock_bh(dev);
3233 }
3234
3235 unsigned dev_get_flags(const struct net_device *dev)
3236 {
3237         unsigned flags;
3238
3239         flags = (dev->flags & ~(IFF_PROMISC |
3240                                 IFF_ALLMULTI |
3241                                 IFF_RUNNING |
3242                                 IFF_LOWER_UP |
3243                                 IFF_DORMANT)) |
3244                 (dev->gflags & (IFF_PROMISC |
3245                                 IFF_ALLMULTI));
3246
3247         if (netif_running(dev)) {
3248                 if (netif_oper_up(dev))
3249                         flags |= IFF_RUNNING;
3250                 if (netif_carrier_ok(dev))
3251                         flags |= IFF_LOWER_UP;
3252                 if (netif_dormant(dev))
3253                         flags |= IFF_DORMANT;
3254         }
3255
3256         return flags;
3257 }
3258
3259 int dev_change_flags(struct net_device *dev, unsigned flags)
3260 {
3261         int ret, changes;
3262         int old_flags = dev->flags;
3263
3264         ASSERT_RTNL();
3265
3266         /*
3267          *      Set the flags on our device.
3268          */
3269
3270         dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
3271                                IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
3272                                IFF_AUTOMEDIA)) |
3273                      (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
3274                                     IFF_ALLMULTI));
3275
3276         /*
3277          *      Load in the correct multicast list now the flags have changed.
3278          */
3279
3280         if (dev->change_rx_flags && (old_flags ^ flags) & IFF_MULTICAST)
3281                 dev->change_rx_flags(dev, IFF_MULTICAST);
3282
3283         dev_set_rx_mode(dev);
3284
3285         /*
3286          *      Have we downed the interface. We handle IFF_UP ourselves
3287          *      according to user attempts to set it, rather than blindly
3288          *      setting it.
3289          */
3290
3291         ret = 0;
3292         if ((old_flags ^ flags) & IFF_UP) {     /* Bit is different  ? */
3293                 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
3294
3295                 if (!ret)
3296                         dev_set_rx_mode(dev);
3297         }
3298
3299         if (dev->flags & IFF_UP &&
3300             ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
3301                                           IFF_VOLATILE)))
3302                 call_netdevice_notifiers(NETDEV_CHANGE, dev);
3303
3304         if ((flags ^ dev->gflags) & IFF_PROMISC) {
3305                 int inc = (flags & IFF_PROMISC) ? +1 : -1;
3306                 dev->gflags ^= IFF_PROMISC;
3307                 dev_set_promiscuity(dev, inc);
3308         }
3309
3310         /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
3311            is important. Some (broken) drivers set IFF_PROMISC, when
3312            IFF_ALLMULTI is requested not asking us and not reporting.
3313          */
3314         if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
3315                 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
3316                 dev->gflags ^= IFF_ALLMULTI;
3317                 dev_set_allmulti(dev, inc);
3318         }
3319
3320         /* Exclude state transition flags, already notified */
3321         changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
3322         if (changes)
3323                 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
3324
3325         return ret;
3326 }
3327
3328 int dev_set_mtu(struct net_device *dev, int new_mtu)
3329 {
3330         int err;
3331
3332         if (new_mtu == dev->mtu)
3333                 return 0;
3334
3335         /*      MTU must be positive.    */
3336         if (new_mtu < 0)
3337                 return -EINVAL;
3338
3339         if (!netif_device_present(dev))
3340                 return -ENODEV;
3341
3342         err = 0;
3343         if (dev->change_mtu)
3344                 err = dev->change_mtu(dev, new_mtu);
3345         else
3346                 dev->mtu = new_mtu;
3347         if (!err && dev->flags & IFF_UP)
3348                 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
3349         return err;
3350 }
3351
3352 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
3353 {
3354         int err;
3355
3356         if (!dev->set_mac_address)
3357                 return -EOPNOTSUPP;
3358         if (sa->sa_family != dev->type)
3359                 return -EINVAL;
3360         if (!netif_device_present(dev))
3361                 return -ENODEV;
3362         err = dev->set_mac_address(dev, sa);
3363         if (!err)
3364                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3365         return err;
3366 }
3367
3368 /*
3369  *      Perform the SIOCxIFxxx calls, inside read_lock(dev_base_lock)
3370  */
3371 static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
3372 {
3373         int err;
3374         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3375
3376         if (!dev)
3377                 return -ENODEV;
3378
3379         switch (cmd) {
3380                 case SIOCGIFFLAGS:      /* Get interface flags */
3381                         ifr->ifr_flags = dev_get_flags(dev);
3382                         return 0;
3383
3384                 case SIOCGIFMETRIC:     /* Get the metric on the interface
3385                                            (currently unused) */
3386                         ifr->ifr_metric = 0;
3387                         return 0;
3388
3389                 case SIOCGIFMTU:        /* Get the MTU of a device */
3390                         ifr->ifr_mtu = dev->mtu;
3391                         return 0;
3392
3393                 case SIOCGIFHWADDR:
3394                         if (!dev->addr_len)
3395                                 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
3396                         else
3397                                 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
3398                                        min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3399                         ifr->ifr_hwaddr.sa_family = dev->type;
3400                         return 0;
3401
3402                 case SIOCGIFSLAVE:
3403                         err = -EINVAL;
3404                         break;
3405
3406                 case SIOCGIFMAP:
3407                         ifr->ifr_map.mem_start = dev->mem_start;
3408                         ifr->ifr_map.mem_end   = dev->mem_end;
3409                         ifr->ifr_map.base_addr = dev->base_addr;
3410                         ifr->ifr_map.irq       = dev->irq;
3411                         ifr->ifr_map.dma       = dev->dma;
3412                         ifr->ifr_map.port      = dev->if_port;
3413                         return 0;
3414
3415                 case SIOCGIFINDEX:
3416                         ifr->ifr_ifindex = dev->ifindex;
3417                         return 0;
3418
3419                 case SIOCGIFTXQLEN:
3420                         ifr->ifr_qlen = dev->tx_queue_len;
3421                         return 0;
3422
3423                 default:
3424                         /* dev_ioctl() should ensure this case
3425                          * is never reached
3426                          */
3427                         WARN_ON(1);
3428                         err = -EINVAL;
3429                         break;
3430
3431         }
3432         return err;
3433 }
3434
3435 /*
3436  *      Perform the SIOCxIFxxx calls, inside rtnl_lock()
3437  */
3438 static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
3439 {
3440         int err;
3441         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3442
3443         if (!dev)
3444                 return -ENODEV;
3445
3446         switch (cmd) {
3447                 case SIOCSIFFLAGS:      /* Set interface flags */
3448                         return dev_change_flags(dev, ifr->ifr_flags);
3449
3450                 case SIOCSIFMETRIC:     /* Set the metric on the interface
3451                                            (currently unused) */
3452                         return -EOPNOTSUPP;
3453
3454                 case SIOCSIFMTU:        /* Set the MTU of a device */
3455                         return dev_set_mtu(dev, ifr->ifr_mtu);
3456
3457                 case SIOCSIFHWADDR:
3458                         return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
3459
3460                 case SIOCSIFHWBROADCAST:
3461                         if (ifr->ifr_hwaddr.sa_family != dev->type)
3462                                 return -EINVAL;
3463                         memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
3464                                min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3465                         call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3466                         return 0;
3467
3468                 case SIOCSIFMAP:
3469                         if (dev->set_config) {
3470                                 if (!netif_device_present(dev))
3471                                         return -ENODEV;
3472                                 return dev->set_config(dev, &ifr->ifr_map);
3473                         }
3474                         return -EOPNOTSUPP;
3475
3476                 case SIOCADDMULTI:
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_add(dev, ifr->ifr_hwaddr.sa_data,
3483                                           dev->addr_len, 1);
3484
3485                 case SIOCDELMULTI:
3486                         if ((!dev->set_multicast_list && !dev->set_rx_mode) ||
3487                             ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3488                                 return -EINVAL;
3489                         if (!netif_device_present(dev))
3490                                 return -ENODEV;
3491                         return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
3492                                              dev->addr_len, 1);
3493
3494                 case SIOCSIFTXQLEN:
3495                         if (ifr->ifr_qlen < 0)
3496                                 return -EINVAL;
3497                         dev->tx_queue_len = ifr->ifr_qlen;
3498                         return 0;
3499
3500                 case SIOCSIFNAME:
3501                         ifr->ifr_newname[IFNAMSIZ-1] = '\0';
3502                         return dev_change_name(dev, ifr->ifr_newname);
3503
3504                 /*
3505                  *      Unknown or private ioctl
3506                  */
3507
3508                 default:
3509                         if ((cmd >= SIOCDEVPRIVATE &&
3510                             cmd <= SIOCDEVPRIVATE + 15) ||
3511                             cmd == SIOCBONDENSLAVE ||
3512                             cmd == SIOCBONDRELEASE ||
3513                             cmd == SIOCBONDSETHWADDR ||
3514                             cmd == SIOCBONDSLAVEINFOQUERY ||
3515                             cmd == SIOCBONDINFOQUERY ||
3516                             cmd == SIOCBONDCHANGEACTIVE ||
3517                             cmd == SIOCGMIIPHY ||
3518                             cmd == SIOCGMIIREG ||
3519                             cmd == SIOCSMIIREG ||
3520                             cmd == SIOCBRADDIF ||
3521                             cmd == SIOCBRDELIF ||
3522                             cmd == SIOCWANDEV) {
3523                                 err = -EOPNOTSUPP;
3524                                 if (dev->do_ioctl) {
3525                                         if (netif_device_present(dev))
3526                                                 err = dev->do_ioctl(dev, ifr,
3527                                                                     cmd);
3528                                         else
3529                                                 err = -ENODEV;
3530                                 }
3531                         } else
3532                                 err = -EINVAL;
3533
3534         }
3535         return err;
3536 }
3537
3538 /*
3539  *      This function handles all "interface"-type I/O control requests. The actual
3540  *      'doing' part of this is dev_ifsioc above.
3541  */
3542
3543 /**
3544  *      dev_ioctl       -       network device ioctl
3545  *      @net: the applicable net namespace
3546  *      @cmd: command to issue
3547  *      @arg: pointer to a struct ifreq in user space
3548  *
3549  *      Issue ioctl functions to devices. This is normally called by the
3550  *      user space syscall interfaces but can sometimes be useful for
3551  *      other purposes. The return value is the return from the syscall if
3552  *      positive or a negative errno code on error.
3553  */
3554
3555 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
3556 {
3557         struct ifreq ifr;
3558         int ret;
3559         char *colon;
3560
3561         /* One special case: SIOCGIFCONF takes ifconf argument
3562            and requires shared lock, because it sleeps writing
3563            to user space.
3564          */
3565
3566         if (cmd == SIOCGIFCONF) {
3567                 rtnl_lock();
3568                 ret = dev_ifconf(net, (char __user *) arg);
3569                 rtnl_unlock();
3570                 return ret;
3571         }
3572         if (cmd == SIOCGIFNAME)
3573                 return dev_ifname(net, (struct ifreq __user *)arg);
3574
3575         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
3576                 return -EFAULT;
3577
3578         ifr.ifr_name[IFNAMSIZ-1] = 0;
3579
3580         colon = strchr(ifr.ifr_name, ':');
3581         if (colon)
3582                 *colon = 0;
3583
3584         /*
3585          *      See which interface the caller is talking about.
3586          */
3587
3588         switch (cmd) {
3589                 /*
3590                  *      These ioctl calls:
3591                  *      - can be done by all.
3592                  *      - atomic and do not require locking.
3593                  *      - return a value
3594                  */
3595                 case SIOCGIFFLAGS:
3596                 case SIOCGIFMETRIC:
3597                 case SIOCGIFMTU:
3598                 case SIOCGIFHWADDR:
3599                 case SIOCGIFSLAVE:
3600                 case SIOCGIFMAP:
3601                 case SIOCGIFINDEX:
3602                 case SIOCGIFTXQLEN:
3603                         dev_load(net, ifr.ifr_name);
3604                         read_lock(&dev_base_lock);
3605                         ret = dev_ifsioc_locked(net, &ifr, cmd);
3606                         read_unlock(&dev_base_lock);
3607                         if (!ret) {
3608                                 if (colon)
3609                                         *colon = ':';
3610                                 if (copy_to_user(arg, &ifr,
3611                                                  sizeof(struct ifreq)))
3612                                         ret = -EFAULT;
3613                         }
3614                         return ret;
3615
3616                 case SIOCETHTOOL:
3617                         dev_load(net, ifr.ifr_name);
3618                         rtnl_lock();
3619                         ret = dev_ethtool(net, &ifr);
3620                         rtnl_unlock();
3621                         if (!ret) {
3622                                 if (colon)
3623                                         *colon = ':';
3624                                 if (copy_to_user(arg, &ifr,
3625                                                  sizeof(struct ifreq)))
3626                                         ret = -EFAULT;
3627                         }
3628                         return ret;
3629
3630                 /*
3631                  *      These ioctl calls:
3632                  *      - require superuser power.
3633                  *      - require strict serialization.
3634                  *      - return a value
3635                  */
3636                 case SIOCGMIIPHY:
3637                 case SIOCGMIIREG:
3638                 case SIOCSIFNAME:
3639                         if (!capable(CAP_NET_ADMIN))
3640                                 return -EPERM;
3641                         dev_load(net, ifr.ifr_name);
3642                         rtnl_lock();
3643                         ret = dev_ifsioc(net, &ifr, cmd);
3644                         rtnl_unlock();
3645                         if (!ret) {
3646                                 if (colon)
3647                                         *colon = ':';
3648                                 if (copy_to_user(arg, &ifr,
3649                                                  sizeof(struct ifreq)))
3650                                         ret = -EFAULT;
3651                         }
3652                         return ret;
3653
3654                 /*
3655                  *      These ioctl calls:
3656                  *      - require superuser power.
3657                  *      - require strict serialization.
3658                  *      - do not return a value
3659                  */
3660                 case SIOCSIFFLAGS:
3661                 case SIOCSIFMETRIC:
3662                 case SIOCSIFMTU:
3663                 case SIOCSIFMAP:
3664                 case SIOCSIFHWADDR:
3665                 case SIOCSIFSLAVE:
3666                 case SIOCADDMULTI:
3667                 case SIOCDELMULTI:
3668                 case SIOCSIFHWBROADCAST:
3669                 case SIOCSIFTXQLEN:
3670                 case SIOCSMIIREG:
3671                 case SIOCBONDENSLAVE:
3672                 case SIOCBONDRELEASE:
3673                 case SIOCBONDSETHWADDR:
3674                 case SIOCBONDCHANGEACTIVE:
3675                 case SIOCBRADDIF:
3676                 case SIOCBRDELIF:
3677                         if (!capable(CAP_NET_ADMIN))
3678                                 return -EPERM;
3679                         /* fall through */
3680                 case SIOCBONDSLAVEINFOQUERY:
3681                 case SIOCBONDINFOQUERY:
3682                         dev_load(net, ifr.ifr_name);
3683                         rtnl_lock();
3684                         ret = dev_ifsioc(net, &ifr, cmd);
3685                         rtnl_unlock();
3686                         return ret;
3687
3688                 case SIOCGIFMEM:
3689                         /* Get the per device memory space. We can add this but
3690                          * currently do not support it */
3691                 case SIOCSIFMEM:
3692                         /* Set the per device memory buffer space.
3693                          * Not applicable in our case */
3694                 case SIOCSIFLINK:
3695                         return -EINVAL;
3696
3697                 /*
3698                  *      Unknown or private ioctl.
3699                  */
3700                 default:
3701                         if (cmd == SIOCWANDEV ||
3702                             (cmd >= SIOCDEVPRIVATE &&
3703                              cmd <= SIOCDEVPRIVATE + 15)) {
3704                                 dev_load(net, ifr.ifr_name);
3705                                 rtnl_lock();
3706                                 ret = dev_ifsioc(net, &ifr, cmd);
3707                                 rtnl_unlock();
3708                                 if (!ret && copy_to_user(arg, &ifr,
3709                                                          sizeof(struct ifreq)))
3710                                         ret = -EFAULT;
3711                                 return ret;
3712                         }
3713                         /* Take care of Wireless Extensions */
3714                         if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
3715                                 return wext_handle_ioctl(net, &ifr, cmd, arg);
3716                         return -EINVAL;
3717         }
3718 }
3719
3720
3721 /**
3722  *      dev_new_index   -       allocate an ifindex
3723  *      @net: the applicable net namespace
3724  *
3725  *      Returns a suitable unique value for a new device interface
3726  *      number.  The caller must hold the rtnl semaphore or the
3727  *      dev_base_lock to be sure it remains unique.
3728  */
3729 static int dev_new_index(struct net *net)
3730 {
3731         static int ifindex;
3732         for (;;) {
3733                 if (++ifindex <= 0)
3734                         ifindex = 1;
3735                 if (!__dev_get_by_index(net, ifindex))
3736                         return ifindex;
3737         }
3738 }
3739
3740 /* Delayed registration/unregisteration */
3741 static DEFINE_SPINLOCK(net_todo_list_lock);
3742 static LIST_HEAD(net_todo_list);
3743
3744 static void net_set_todo(struct net_device *dev)
3745 {
3746         spin_lock(&net_todo_list_lock);
3747         list_add_tail(&dev->todo_list, &net_todo_list);
3748         spin_unlock(&net_todo_list_lock);
3749 }
3750
3751 static void rollback_registered(struct net_device *dev)
3752 {
3753         BUG_ON(dev_boot_phase);
3754         ASSERT_RTNL();
3755
3756         /* Some devices call without registering for initialization unwind. */
3757         if (dev->reg_state == NETREG_UNINITIALIZED) {
3758                 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3759                                   "was registered\n", dev->name, dev);
3760
3761                 WARN_ON(1);
3762                 return;
3763         }
3764
3765         BUG_ON(dev->reg_state != NETREG_REGISTERED);
3766
3767         /* If device is running, close it first. */
3768         dev_close(dev);
3769
3770         /* And unlink it from device chain. */
3771         unlist_netdevice(dev);
3772
3773         dev->reg_state = NETREG_UNREGISTERING;
3774
3775         synchronize_net();
3776
3777         /* Shutdown queueing discipline. */
3778         dev_shutdown(dev);
3779
3780
3781         /* Notify protocols, that we are about to destroy
3782            this device. They should clean all the things.
3783         */
3784         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
3785
3786         /*
3787          *      Flush the unicast and multicast chains
3788          */
3789         dev_addr_discard(dev);
3790
3791         if (dev->uninit)
3792                 dev->uninit(dev);
3793
3794         /* Notifier chain MUST detach us from master device. */
3795         BUG_TRAP(!dev->master);
3796
3797         /* Remove entries from kobject tree */
3798         netdev_unregister_kobject(dev);
3799
3800         synchronize_net();
3801
3802         dev_put(dev);
3803 }
3804
3805 static void __netdev_init_queue_locks_one(struct netdev_queue *dev_queue,
3806                                           struct net_device *dev)
3807 {
3808         spin_lock_init(&dev_queue->_xmit_lock);
3809         netdev_set_lockdep_class(&dev_queue->_xmit_lock, dev->type);
3810         dev_queue->xmit_lock_owner = -1;
3811 }
3812
3813 static void netdev_init_queue_locks(struct net_device *dev)
3814 {
3815         __netdev_init_queue_locks_one(&dev->tx_queue, dev);
3816         __netdev_init_queue_locks_one(&dev->rx_queue, dev);
3817 }
3818
3819 /**
3820  *      register_netdevice      - register a network device
3821  *      @dev: device to register
3822  *
3823  *      Take a completed network device structure and add it to the kernel
3824  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3825  *      chain. 0 is returned on success. A negative errno code is returned
3826  *      on a failure to set up the device, or if the name is a duplicate.
3827  *
3828  *      Callers must hold the rtnl semaphore. You may want
3829  *      register_netdev() instead of this.
3830  *
3831  *      BUGS:
3832  *      The locking appears insufficient to guarantee two parallel registers
3833  *      will not get the same name.
3834  */
3835
3836 int register_netdevice(struct net_device *dev)
3837 {
3838         struct hlist_head *head;
3839         struct hlist_node *p;
3840         int ret;
3841         struct net *net;
3842
3843         BUG_ON(dev_boot_phase);
3844         ASSERT_RTNL();
3845
3846         might_sleep();
3847
3848         /* When net_device's are persistent, this will be fatal. */
3849         BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
3850         BUG_ON(!dev_net(dev));
3851         net = dev_net(dev);
3852
3853         spin_lock_init(&dev->addr_list_lock);
3854         netdev_init_queue_locks(dev);
3855
3856         dev->iflink = -1;
3857
3858         /* Init, if this function is available */
3859         if (dev->init) {
3860                 ret = dev->init(dev);
3861                 if (ret) {
3862                         if (ret > 0)
3863                                 ret = -EIO;
3864                         goto out;
3865                 }
3866         }
3867
3868         if (!dev_valid_name(dev->name)) {
3869                 ret = -EINVAL;
3870                 goto err_uninit;
3871         }
3872
3873         dev->ifindex = dev_new_index(net);
3874         if (dev->iflink == -1)
3875                 dev->iflink = dev->ifindex;
3876
3877         /* Check for existence of name */
3878         head = dev_name_hash(net, dev->name);
3879         hlist_for_each(p, head) {
3880                 struct net_device *d
3881                         = hlist_entry(p, struct net_device, name_hlist);
3882                 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
3883                         ret = -EEXIST;
3884                         goto err_uninit;
3885                 }
3886         }
3887
3888         /* Fix illegal checksum combinations */
3889         if ((dev->features & NETIF_F_HW_CSUM) &&
3890             (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3891                 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
3892                        dev->name);
3893                 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
3894         }
3895
3896         if ((dev->features & NETIF_F_NO_CSUM) &&
3897             (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3898                 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
3899                        dev->name);
3900                 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
3901         }
3902
3903
3904         /* Fix illegal SG+CSUM combinations. */
3905         if ((dev->features & NETIF_F_SG) &&
3906             !(dev->features & NETIF_F_ALL_CSUM)) {
3907                 printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no checksum feature.\n",
3908                        dev->name);
3909                 dev->features &= ~NETIF_F_SG;
3910         }
3911
3912         /* TSO requires that SG is present as well. */
3913         if ((dev->features & NETIF_F_TSO) &&
3914             !(dev->features & NETIF_F_SG)) {
3915                 printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no SG feature.\n",
3916                        dev->name);
3917                 dev->features &= ~NETIF_F_TSO;
3918         }
3919         if (dev->features & NETIF_F_UFO) {
3920                 if (!(dev->features & NETIF_F_HW_CSUM)) {
3921                         printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3922                                         "NETIF_F_HW_CSUM feature.\n",
3923                                                         dev->name);
3924                         dev->features &= ~NETIF_F_UFO;
3925                 }
3926                 if (!(dev->features & NETIF_F_SG)) {
3927                         printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3928                                         "NETIF_F_SG feature.\n",
3929                                         dev->name);
3930                         dev->features &= ~NETIF_F_UFO;
3931                 }
3932         }
3933
3934         netdev_initialize_kobject(dev);
3935         ret = netdev_register_kobject(dev);
3936         if (ret)
3937                 goto err_uninit;
3938         dev->reg_state = NETREG_REGISTERED;
3939
3940         /*
3941          *      Default initial state at registry is that the
3942          *      device is present.
3943          */
3944
3945         set_bit(__LINK_STATE_PRESENT, &dev->state);
3946
3947         dev_init_scheduler(dev);
3948         dev_hold(dev);
3949         list_netdevice(dev);
3950
3951         /* Notify protocols, that a new device appeared. */
3952         ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
3953         ret = notifier_to_errno(ret);
3954         if (ret) {
3955                 rollback_registered(dev);
3956                 dev->reg_state = NETREG_UNREGISTERED;
3957         }
3958
3959 out:
3960         return ret;
3961
3962 err_uninit:
3963         if (dev->uninit)
3964                 dev->uninit(dev);
3965         goto out;
3966 }
3967
3968 /**
3969  *      register_netdev - register a network device
3970  *      @dev: device to register
3971  *
3972  *      Take a completed network device structure and add it to the kernel
3973  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3974  *      chain. 0 is returned on success. A negative errno code is returned
3975  *      on a failure to set up the device, or if the name is a duplicate.
3976  *
3977  *      This is a wrapper around register_netdevice that takes the rtnl semaphore
3978  *      and expands the device name if you passed a format string to
3979  *      alloc_netdev.
3980  */
3981 int register_netdev(struct net_device *dev)
3982 {
3983         int err;
3984
3985         rtnl_lock();
3986
3987         /*
3988          * If the name is a format string the caller wants us to do a
3989          * name allocation.
3990          */
3991         if (strchr(dev->name, '%')) {
3992                 err = dev_alloc_name(dev, dev->name);
3993                 if (err < 0)
3994                         goto out;
3995         }
3996
3997         err = register_netdevice(dev);
3998 out:
3999         rtnl_unlock();
4000         return err;
4001 }
4002 EXPORT_SYMBOL(register_netdev);
4003
4004 /*
4005  * netdev_wait_allrefs - wait until all references are gone.
4006  *
4007  * This is called when unregistering network devices.
4008  *
4009  * Any protocol or device that holds a reference should register
4010  * for netdevice notification, and cleanup and put back the
4011  * reference if they receive an UNREGISTER event.
4012  * We can get stuck here if buggy protocols don't correctly
4013  * call dev_put.
4014  */
4015 static void netdev_wait_allrefs(struct net_device *dev)
4016 {
4017         unsigned long rebroadcast_time, warning_time;
4018
4019         rebroadcast_time = warning_time = jiffies;
4020         while (atomic_read(&dev->refcnt) != 0) {
4021                 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
4022                         rtnl_lock();
4023
4024                         /* Rebroadcast unregister notification */
4025                         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4026
4027                         if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
4028                                      &dev->state)) {
4029                                 /* We must not have linkwatch events
4030                                  * pending on unregister. If this
4031                                  * happens, we simply run the queue
4032                                  * unscheduled, resulting in a noop
4033                                  * for this device.
4034                                  */
4035                                 linkwatch_run_queue();
4036                         }
4037
4038                         __rtnl_unlock();
4039
4040                         rebroadcast_time = jiffies;
4041                 }
4042
4043                 msleep(250);
4044
4045                 if (time_after(jiffies, warning_time + 10 * HZ)) {
4046                         printk(KERN_EMERG "unregister_netdevice: "
4047                                "waiting for %s to become free. Usage "
4048                                "count = %d\n",
4049                                dev->name, atomic_read(&dev->refcnt));
4050                         warning_time = jiffies;
4051                 }
4052         }
4053 }
4054
4055 /* The sequence is:
4056  *
4057  *      rtnl_lock();
4058  *      ...
4059  *      register_netdevice(x1);
4060  *      register_netdevice(x2);
4061  *      ...
4062  *      unregister_netdevice(y1);
4063  *      unregister_netdevice(y2);
4064  *      ...
4065  *      rtnl_unlock();
4066  *      free_netdev(y1);
4067  *      free_netdev(y2);
4068  *
4069  * We are invoked by rtnl_unlock() after it drops the semaphore.
4070  * This allows us to deal with problems:
4071  * 1) We can delete sysfs objects which invoke hotplug
4072  *    without deadlocking with linkwatch via keventd.
4073  * 2) Since we run with the RTNL semaphore not held, we can sleep
4074  *    safely in order to wait for the netdev refcnt to drop to zero.
4075  */
4076 static DEFINE_MUTEX(net_todo_run_mutex);
4077 void netdev_run_todo(void)
4078 {
4079         struct list_head list;
4080
4081         /* Need to guard against multiple cpu's getting out of order. */
4082         mutex_lock(&net_todo_run_mutex);
4083
4084         /* Not safe to do outside the semaphore.  We must not return
4085          * until all unregister events invoked by the local processor
4086          * have been completed (either by this todo run, or one on
4087          * another cpu).
4088          */
4089         if (list_empty(&net_todo_list))
4090                 goto out;
4091
4092         /* Snapshot list, allow later requests */
4093         spin_lock(&net_todo_list_lock);
4094         list_replace_init(&net_todo_list, &list);
4095         spin_unlock(&net_todo_list_lock);
4096
4097         while (!list_empty(&list)) {
4098                 struct net_device *dev
4099                         = list_entry(list.next, struct net_device, todo_list);
4100                 list_del(&dev->todo_list);
4101
4102                 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
4103                         printk(KERN_ERR "network todo '%s' but state %d\n",
4104                                dev->name, dev->reg_state);
4105                         dump_stack();
4106                         continue;
4107                 }
4108
4109                 dev->reg_state = NETREG_UNREGISTERED;
4110
4111                 netdev_wait_allrefs(dev);
4112
4113                 /* paranoia */
4114                 BUG_ON(atomic_read(&dev->refcnt));
4115                 BUG_TRAP(!dev->ip_ptr);
4116                 BUG_TRAP(!dev->ip6_ptr);
4117                 BUG_TRAP(!dev->dn_ptr);
4118
4119                 if (dev->destructor)
4120                         dev->destructor(dev);
4121
4122                 /* Free network device */
4123                 kobject_put(&dev->dev.kobj);
4124         }
4125
4126 out:
4127         mutex_unlock(&net_todo_run_mutex);
4128 }
4129
4130 static struct net_device_stats *internal_stats(struct net_device *dev)
4131 {
4132         return &dev->stats;
4133 }
4134
4135 static void netdev_init_one_queue(struct net_device *dev,
4136                                   struct netdev_queue *queue)
4137 {
4138         spin_lock_init(&queue->lock);
4139         queue->dev = dev;
4140 }
4141
4142 static void netdev_init_queues(struct net_device *dev)
4143 {
4144         netdev_init_one_queue(dev, &dev->rx_queue);
4145         netdev_init_one_queue(dev, &dev->tx_queue);
4146 }
4147
4148 /**
4149  *      alloc_netdev_mq - allocate network device
4150  *      @sizeof_priv:   size of private data to allocate space for
4151  *      @name:          device name format string
4152  *      @setup:         callback to initialize device
4153  *      @queue_count:   the number of subqueues to allocate
4154  *
4155  *      Allocates a struct net_device with private data area for driver use
4156  *      and performs basic initialization.  Also allocates subquue structs
4157  *      for each queue on the device at the end of the netdevice.
4158  */
4159 struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
4160                 void (*setup)(struct net_device *), unsigned int queue_count)
4161 {
4162         void *p;
4163         struct net_device *dev;
4164         int alloc_size;
4165
4166         BUG_ON(strlen(name) >= sizeof(dev->name));
4167
4168         alloc_size = sizeof(struct net_device) +
4169                      sizeof(struct net_device_subqueue) * (queue_count - 1);
4170         if (sizeof_priv) {
4171                 /* ensure 32-byte alignment of private area */
4172                 alloc_size = (alloc_size + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
4173                 alloc_size += sizeof_priv;
4174         }
4175         /* ensure 32-byte alignment of whole construct */
4176         alloc_size += NETDEV_ALIGN_CONST;
4177
4178         p = kzalloc(alloc_size, GFP_KERNEL);
4179         if (!p) {
4180                 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
4181                 return NULL;
4182         }
4183
4184         dev = (struct net_device *)
4185                 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
4186         dev->padded = (char *)dev - (char *)p;
4187         dev_net_set(dev, &init_net);
4188
4189         if (sizeof_priv) {
4190                 dev->priv = ((char *)dev +
4191                              ((sizeof(struct net_device) +
4192                                (sizeof(struct net_device_subqueue) *
4193                                 (queue_count - 1)) + NETDEV_ALIGN_CONST)
4194                               & ~NETDEV_ALIGN_CONST));
4195         }
4196
4197         dev->egress_subqueue_count = queue_count;
4198         dev->gso_max_size = GSO_MAX_SIZE;
4199
4200         netdev_init_queues(dev);
4201
4202         dev->get_stats = internal_stats;
4203         netpoll_netdev_init(dev);
4204         setup(dev);
4205         strcpy(dev->name, name);
4206         return dev;
4207 }
4208 EXPORT_SYMBOL(alloc_netdev_mq);
4209
4210 /**
4211  *      free_netdev - free network device
4212  *      @dev: device
4213  *
4214  *      This function does the last stage of destroying an allocated device
4215  *      interface. The reference to the device object is released.
4216  *      If this is the last reference then it will be freed.
4217  */
4218 void free_netdev(struct net_device *dev)
4219 {
4220         release_net(dev_net(dev));
4221
4222         /*  Compatibility with error handling in drivers */
4223         if (dev->reg_state == NETREG_UNINITIALIZED) {
4224                 kfree((char *)dev - dev->padded);
4225                 return;
4226         }
4227
4228         BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
4229         dev->reg_state = NETREG_RELEASED;
4230
4231         /* will free via device release */
4232         put_device(&dev->dev);
4233 }
4234
4235 /* Synchronize with packet receive processing. */
4236 void synchronize_net(void)
4237 {
4238         might_sleep();
4239         synchronize_rcu();
4240 }
4241
4242 /**
4243  *      unregister_netdevice - remove device from the kernel
4244  *      @dev: device
4245  *
4246  *      This function shuts down a device interface and removes it
4247  *      from the kernel tables.
4248  *
4249  *      Callers must hold the rtnl semaphore.  You may want
4250  *      unregister_netdev() instead of this.
4251  */
4252
4253 void unregister_netdevice(struct net_device *dev)
4254 {
4255         ASSERT_RTNL();
4256
4257         rollback_registered(dev);
4258         /* Finish processing unregister after unlock */
4259         net_set_todo(dev);
4260 }
4261
4262 /**
4263  *      unregister_netdev - remove device from the kernel
4264  *      @dev: device
4265  *
4266  *      This function shuts down a device interface and removes it
4267  *      from the kernel tables.
4268  *
4269  *      This is just a wrapper for unregister_netdevice that takes
4270  *      the rtnl semaphore.  In general you want to use this and not
4271  *      unregister_netdevice.
4272  */
4273 void unregister_netdev(struct net_device *dev)
4274 {
4275         rtnl_lock();
4276         unregister_netdevice(dev);
4277         rtnl_unlock();
4278 }
4279
4280 EXPORT_SYMBOL(unregister_netdev);
4281
4282 /**
4283  *      dev_change_net_namespace - move device to different nethost namespace
4284  *      @dev: device
4285  *      @net: network namespace
4286  *      @pat: If not NULL name pattern to try if the current device name
4287  *            is already taken in the destination network namespace.
4288  *
4289  *      This function shuts down a device interface and moves it
4290  *      to a new network namespace. On success 0 is returned, on
4291  *      a failure a netagive errno code is returned.
4292  *
4293  *      Callers must hold the rtnl semaphore.
4294  */
4295
4296 int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
4297 {
4298         char buf[IFNAMSIZ];
4299         const char *destname;
4300         int err;
4301
4302         ASSERT_RTNL();
4303
4304         /* Don't allow namespace local devices to be moved. */
4305         err = -EINVAL;
4306         if (dev->features & NETIF_F_NETNS_LOCAL)
4307                 goto out;
4308
4309         /* Ensure the device has been registrered */
4310         err = -EINVAL;
4311         if (dev->reg_state != NETREG_REGISTERED)
4312                 goto out;
4313
4314         /* Get out if there is nothing todo */
4315         err = 0;
4316         if (net_eq(dev_net(dev), net))
4317                 goto out;
4318
4319         /* Pick the destination device name, and ensure
4320          * we can use it in the destination network namespace.
4321          */
4322         err = -EEXIST;
4323         destname = dev->name;
4324         if (__dev_get_by_name(net, destname)) {
4325                 /* We get here if we can't use the current device name */
4326                 if (!pat)
4327                         goto out;
4328                 if (!dev_valid_name(pat))
4329                         goto out;
4330                 if (strchr(pat, '%')) {
4331                         if (__dev_alloc_name(net, pat, buf) < 0)
4332                                 goto out;
4333                         destname = buf;
4334                 } else
4335                         destname = pat;
4336                 if (__dev_get_by_name(net, destname))
4337                         goto out;
4338         }
4339
4340         /*
4341          * And now a mini version of register_netdevice unregister_netdevice.
4342          */
4343
4344         /* If device is running close it first. */
4345         dev_close(dev);
4346
4347         /* And unlink it from device chain */
4348         err = -ENODEV;
4349         unlist_netdevice(dev);
4350
4351         synchronize_net();
4352
4353         /* Shutdown queueing discipline. */
4354         dev_shutdown(dev);
4355
4356         /* Notify protocols, that we are about to destroy
4357            this device. They should clean all the things.
4358         */
4359         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4360
4361         /*
4362          *      Flush the unicast and multicast chains
4363          */
4364         dev_addr_discard(dev);
4365
4366         /* Actually switch the network namespace */
4367         dev_net_set(dev, net);
4368
4369         /* Assign the new device name */
4370         if (destname != dev->name)
4371                 strcpy(dev->name, destname);
4372
4373         /* If there is an ifindex conflict assign a new one */
4374         if (__dev_get_by_index(net, dev->ifindex)) {
4375                 int iflink = (dev->iflink == dev->ifindex);
4376                 dev->ifindex = dev_new_index(net);
4377                 if (iflink)
4378                         dev->iflink = dev->ifindex;
4379         }
4380
4381         /* Fixup kobjects */
4382         netdev_unregister_kobject(dev);
4383         err = netdev_register_kobject(dev);
4384         WARN_ON(err);
4385
4386         /* Add the device back in the hashes */
4387         list_netdevice(dev);
4388
4389         /* Notify protocols, that a new device appeared. */
4390         call_netdevice_notifiers(NETDEV_REGISTER, dev);
4391
4392         synchronize_net();
4393         err = 0;
4394 out:
4395         return err;
4396 }
4397
4398 static int dev_cpu_callback(struct notifier_block *nfb,
4399                             unsigned long action,
4400                             void *ocpu)
4401 {
4402         struct sk_buff **list_skb;
4403         struct netdev_queue **list_net;
4404         struct sk_buff *skb;
4405         unsigned int cpu, oldcpu = (unsigned long)ocpu;
4406         struct softnet_data *sd, *oldsd;
4407
4408         if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
4409                 return NOTIFY_OK;
4410
4411         local_irq_disable();
4412         cpu = smp_processor_id();
4413         sd = &per_cpu(softnet_data, cpu);
4414         oldsd = &per_cpu(softnet_data, oldcpu);
4415
4416         /* Find end of our completion_queue. */
4417         list_skb = &sd->completion_queue;
4418         while (*list_skb)
4419                 list_skb = &(*list_skb)->next;
4420         /* Append completion queue from offline CPU. */
4421         *list_skb = oldsd->completion_queue;
4422         oldsd->completion_queue = NULL;
4423
4424         /* Find end of our output_queue. */
4425         list_net = &sd->output_queue;
4426         while (*list_net)
4427                 list_net = &(*list_net)->next_sched;
4428         /* Append output queue from offline CPU. */
4429         *list_net = oldsd->output_queue;
4430         oldsd->output_queue = NULL;
4431
4432         raise_softirq_irqoff(NET_TX_SOFTIRQ);
4433         local_irq_enable();
4434
4435         /* Process offline CPU's input_pkt_queue */
4436         while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
4437                 netif_rx(skb);
4438
4439         return NOTIFY_OK;
4440 }
4441
4442 #ifdef CONFIG_NET_DMA
4443 /**
4444  * net_dma_rebalance - try to maintain one DMA channel per CPU
4445  * @net_dma: DMA client and associated data (lock, channels, channel_mask)
4446  *
4447  * This is called when the number of channels allocated to the net_dma client
4448  * changes.  The net_dma client tries to have one DMA channel per CPU.
4449  */
4450
4451 static void net_dma_rebalance(struct net_dma *net_dma)
4452 {
4453         unsigned int cpu, i, n, chan_idx;
4454         struct dma_chan *chan;
4455
4456         if (cpus_empty(net_dma->channel_mask)) {
4457                 for_each_online_cpu(cpu)
4458                         rcu_assign_pointer(per_cpu(softnet_data, cpu).net_dma, NULL);
4459                 return;
4460         }
4461
4462         i = 0;
4463         cpu = first_cpu(cpu_online_map);
4464
4465         for_each_cpu_mask(chan_idx, net_dma->channel_mask) {
4466                 chan = net_dma->channels[chan_idx];
4467
4468                 n = ((num_online_cpus() / cpus_weight(net_dma->channel_mask))
4469                    + (i < (num_online_cpus() %
4470                         cpus_weight(net_dma->channel_mask)) ? 1 : 0));
4471
4472                 while(n) {
4473                         per_cpu(softnet_data, cpu).net_dma = chan;
4474                         cpu = next_cpu(cpu, cpu_online_map);
4475                         n--;
4476                 }
4477                 i++;
4478         }
4479 }
4480
4481 /**
4482  * netdev_dma_event - event callback for the net_dma_client
4483  * @client: should always be net_dma_client
4484  * @chan: DMA channel for the event
4485  * @state: DMA state to be handled
4486  */
4487 static enum dma_state_client
4488 netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
4489         enum dma_state state)
4490 {
4491         int i, found = 0, pos = -1;
4492         struct net_dma *net_dma =
4493                 container_of(client, struct net_dma, client);
4494         enum dma_state_client ack = DMA_DUP; /* default: take no action */
4495
4496         spin_lock(&net_dma->lock);
4497         switch (state) {
4498         case DMA_RESOURCE_AVAILABLE:
4499                 for (i = 0; i < nr_cpu_ids; i++)
4500                         if (net_dma->channels[i] == chan) {
4501                                 found = 1;
4502                                 break;
4503                         } else if (net_dma->channels[i] == NULL && pos < 0)
4504                                 pos = i;
4505
4506                 if (!found && pos >= 0) {
4507                         ack = DMA_ACK;
4508                         net_dma->channels[pos] = chan;
4509                         cpu_set(pos, net_dma->channel_mask);
4510                         net_dma_rebalance(net_dma);
4511                 }
4512                 break;
4513         case DMA_RESOURCE_REMOVED:
4514                 for (i = 0; i < nr_cpu_ids; i++)
4515                         if (net_dma->channels[i] == chan) {
4516                                 found = 1;
4517                                 pos = i;
4518                                 break;
4519                         }
4520
4521                 if (found) {
4522                         ack = DMA_ACK;
4523                         cpu_clear(pos, net_dma->channel_mask);
4524                         net_dma->channels[i] = NULL;
4525                         net_dma_rebalance(net_dma);
4526                 }
4527                 break;
4528         default:
4529                 break;
4530         }
4531         spin_unlock(&net_dma->lock);
4532
4533         return ack;
4534 }
4535
4536 /**
4537  * netdev_dma_regiser - register the networking subsystem as a DMA client
4538  */
4539 static int __init netdev_dma_register(void)
4540 {
4541         net_dma.channels = kzalloc(nr_cpu_ids * sizeof(struct net_dma),
4542                                                                 GFP_KERNEL);
4543         if (unlikely(!net_dma.channels)) {
4544                 printk(KERN_NOTICE
4545                                 "netdev_dma: no memory for net_dma.channels\n");
4546                 return -ENOMEM;
4547         }
4548         spin_lock_init(&net_dma.lock);
4549         dma_cap_set(DMA_MEMCPY, net_dma.client.cap_mask);
4550         dma_async_client_register(&net_dma.client);
4551         dma_async_client_chan_request(&net_dma.client);
4552         return 0;
4553 }
4554
4555 #else
4556 static int __init netdev_dma_register(void) { return -ENODEV; }
4557 #endif /* CONFIG_NET_DMA */
4558
4559 /**
4560  *      netdev_compute_feature - compute conjunction of two feature sets
4561  *      @all: first feature set
4562  *      @one: second feature set
4563  *
4564  *      Computes a new feature set after adding a device with feature set
4565  *      @one to the master device with current feature set @all.  Returns
4566  *      the new feature set.
4567  */
4568 int netdev_compute_features(unsigned long all, unsigned long one)
4569 {
4570         /* if device needs checksumming, downgrade to hw checksumming */
4571         if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
4572                 all ^= NETIF_F_NO_CSUM | NETIF_F_HW_CSUM;
4573
4574         /* if device can't do all checksum, downgrade to ipv4/ipv6 */
4575         if (all & NETIF_F_HW_CSUM && !(one & NETIF_F_HW_CSUM))
4576                 all ^= NETIF_F_HW_CSUM
4577                         | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
4578
4579         if (one & NETIF_F_GSO)
4580                 one |= NETIF_F_GSO_SOFTWARE;
4581         one |= NETIF_F_GSO;
4582
4583         /* If even one device supports robust GSO, enable it for all. */
4584         if (one & NETIF_F_GSO_ROBUST)
4585                 all |= NETIF_F_GSO_ROBUST;
4586
4587         all &= one | NETIF_F_LLTX;
4588
4589         if (!(all & NETIF_F_ALL_CSUM))
4590                 all &= ~NETIF_F_SG;
4591         if (!(all & NETIF_F_SG))
4592                 all &= ~NETIF_F_GSO_MASK;
4593
4594         return all;
4595 }
4596 EXPORT_SYMBOL(netdev_compute_features);
4597
4598 static struct hlist_head *netdev_create_hash(void)
4599 {
4600         int i;
4601         struct hlist_head *hash;
4602
4603         hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
4604         if (hash != NULL)
4605                 for (i = 0; i < NETDEV_HASHENTRIES; i++)
4606                         INIT_HLIST_HEAD(&hash[i]);
4607
4608         return hash;
4609 }
4610
4611 /* Initialize per network namespace state */
4612 static int __net_init netdev_init(struct net *net)
4613 {
4614         INIT_LIST_HEAD(&net->dev_base_head);
4615
4616         net->dev_name_head = netdev_create_hash();
4617         if (net->dev_name_head == NULL)
4618                 goto err_name;
4619
4620         net->dev_index_head = netdev_create_hash();
4621         if (net->dev_index_head == NULL)
4622                 goto err_idx;
4623
4624         return 0;
4625
4626 err_idx:
4627         kfree(net->dev_name_head);
4628 err_name:
4629         return -ENOMEM;
4630 }
4631
4632 static void __net_exit netdev_exit(struct net *net)
4633 {
4634         kfree(net->dev_name_head);
4635         kfree(net->dev_index_head);
4636 }
4637
4638 static struct pernet_operations __net_initdata netdev_net_ops = {
4639         .init = netdev_init,
4640         .exit = netdev_exit,
4641 };
4642
4643 static void __net_exit default_device_exit(struct net *net)
4644 {
4645         struct net_device *dev, *next;
4646         /*
4647          * Push all migratable of the network devices back to the
4648          * initial network namespace
4649          */
4650         rtnl_lock();
4651         for_each_netdev_safe(net, dev, next) {
4652                 int err;
4653                 char fb_name[IFNAMSIZ];
4654
4655                 /* Ignore unmoveable devices (i.e. loopback) */
4656                 if (dev->features & NETIF_F_NETNS_LOCAL)
4657                         continue;
4658
4659                 /* Push remaing network devices to init_net */
4660                 snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex);
4661                 err = dev_change_net_namespace(dev, &init_net, fb_name);
4662                 if (err) {
4663                         printk(KERN_EMERG "%s: failed to move %s to init_net: %d\n",
4664                                 __func__, dev->name, err);
4665                         BUG();
4666                 }
4667         }
4668         rtnl_unlock();
4669 }
4670
4671 static struct pernet_operations __net_initdata default_device_ops = {
4672         .exit = default_device_exit,
4673 };
4674
4675 /*
4676  *      Initialize the DEV module. At boot time this walks the device list and
4677  *      unhooks any devices that fail to initialise (normally hardware not
4678  *      present) and leaves us with a valid list of present and active devices.
4679  *
4680  */
4681
4682 /*
4683  *       This is called single threaded during boot, so no need
4684  *       to take the rtnl semaphore.
4685  */
4686 static int __init net_dev_init(void)
4687 {
4688         int i, rc = -ENOMEM;
4689
4690         BUG_ON(!dev_boot_phase);
4691
4692         if (dev_proc_init())
4693                 goto out;
4694
4695         if (netdev_kobject_init())
4696                 goto out;
4697
4698         INIT_LIST_HEAD(&ptype_all);
4699         for (i = 0; i < PTYPE_HASH_SIZE; i++)
4700                 INIT_LIST_HEAD(&ptype_base[i]);
4701
4702         if (register_pernet_subsys(&netdev_net_ops))
4703                 goto out;
4704
4705         if (register_pernet_device(&default_device_ops))
4706                 goto out;
4707
4708         /*
4709          *      Initialise the packet receive queues.
4710          */
4711
4712         for_each_possible_cpu(i) {
4713                 struct softnet_data *queue;
4714
4715                 queue = &per_cpu(softnet_data, i);
4716                 skb_queue_head_init(&queue->input_pkt_queue);
4717                 queue->completion_queue = NULL;
4718                 INIT_LIST_HEAD(&queue->poll_list);
4719
4720                 queue->backlog.poll = process_backlog;
4721                 queue->backlog.weight = weight_p;
4722         }
4723
4724         netdev_dma_register();
4725
4726         dev_boot_phase = 0;
4727
4728         open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
4729         open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
4730
4731         hotcpu_notifier(dev_cpu_callback, 0);
4732         dst_init();
4733         dev_mcast_init();
4734         rc = 0;
4735 out:
4736         return rc;
4737 }
4738
4739 subsys_initcall(net_dev_init);
4740
4741 EXPORT_SYMBOL(__dev_get_by_index);
4742 EXPORT_SYMBOL(__dev_get_by_name);
4743 EXPORT_SYMBOL(__dev_remove_pack);
4744 EXPORT_SYMBOL(dev_valid_name);
4745 EXPORT_SYMBOL(dev_add_pack);
4746 EXPORT_SYMBOL(dev_alloc_name);
4747 EXPORT_SYMBOL(dev_close);
4748 EXPORT_SYMBOL(dev_get_by_flags);
4749 EXPORT_SYMBOL(dev_get_by_index);
4750 EXPORT_SYMBOL(dev_get_by_name);
4751 EXPORT_SYMBOL(dev_open);
4752 EXPORT_SYMBOL(dev_queue_xmit);
4753 EXPORT_SYMBOL(dev_remove_pack);
4754 EXPORT_SYMBOL(dev_set_allmulti);
4755 EXPORT_SYMBOL(dev_set_promiscuity);
4756 EXPORT_SYMBOL(dev_change_flags);
4757 EXPORT_SYMBOL(dev_set_mtu);
4758 EXPORT_SYMBOL(dev_set_mac_address);
4759 EXPORT_SYMBOL(free_netdev);
4760 EXPORT_SYMBOL(netdev_boot_setup_check);
4761 EXPORT_SYMBOL(netdev_set_master);
4762 EXPORT_SYMBOL(netdev_state_change);
4763 EXPORT_SYMBOL(netif_receive_skb);
4764 EXPORT_SYMBOL(netif_rx);
4765 EXPORT_SYMBOL(register_gifconf);
4766 EXPORT_SYMBOL(register_netdevice);
4767 EXPORT_SYMBOL(register_netdevice_notifier);
4768 EXPORT_SYMBOL(skb_checksum_help);
4769 EXPORT_SYMBOL(synchronize_net);
4770 EXPORT_SYMBOL(unregister_netdevice);
4771 EXPORT_SYMBOL(unregister_netdevice_notifier);
4772 EXPORT_SYMBOL(net_enable_timestamp);
4773 EXPORT_SYMBOL(net_disable_timestamp);
4774 EXPORT_SYMBOL(dev_get_flags);
4775
4776 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
4777 EXPORT_SYMBOL(br_handle_frame_hook);
4778 EXPORT_SYMBOL(br_fdb_get_hook);
4779 EXPORT_SYMBOL(br_fdb_put_hook);
4780 #endif
4781
4782 #ifdef CONFIG_KMOD
4783 EXPORT_SYMBOL(dev_load);
4784 #endif
4785
4786 EXPORT_PER_CPU_SYMBOL(softnet_data);