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