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