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