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