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