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