Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/aoe-2.6
[sfrench/cifs-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         int err;
981
982         rtnl_lock();
983         err = notifier_chain_unregister(&netdev_chain, nb);
984         rtnl_unlock();
985         return err;
986 }
987
988 /**
989  *      call_netdevice_notifiers - call all network notifier blocks
990  *      @val: value passed unmodified to notifier function
991  *      @v:   pointer passed unmodified to notifier function
992  *
993  *      Call all network notifier blocks.  Parameters and return value
994  *      are as for notifier_call_chain().
995  */
996
997 int call_netdevice_notifiers(unsigned long val, void *v)
998 {
999         return notifier_call_chain(&netdev_chain, val, v);
1000 }
1001
1002 /* When > 0 there are consumers of rx skb time stamps */
1003 static atomic_t netstamp_needed = ATOMIC_INIT(0);
1004
1005 void net_enable_timestamp(void)
1006 {
1007         atomic_inc(&netstamp_needed);
1008 }
1009
1010 void net_disable_timestamp(void)
1011 {
1012         atomic_dec(&netstamp_needed);
1013 }
1014
1015 void __net_timestamp(struct sk_buff *skb)
1016 {
1017         struct timeval tv;
1018
1019         do_gettimeofday(&tv);
1020         skb_set_timestamp(skb, &tv);
1021 }
1022 EXPORT_SYMBOL(__net_timestamp);
1023
1024 static inline void net_timestamp(struct sk_buff *skb)
1025 {
1026         if (atomic_read(&netstamp_needed))
1027                 __net_timestamp(skb);
1028         else {
1029                 skb->tstamp.off_sec = 0;
1030                 skb->tstamp.off_usec = 0;
1031         }
1032 }
1033
1034 /*
1035  *      Support routine. Sends outgoing frames to any network
1036  *      taps currently in use.
1037  */
1038
1039 void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1040 {
1041         struct packet_type *ptype;
1042
1043         net_timestamp(skb);
1044
1045         rcu_read_lock();
1046         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1047                 /* Never send packets back to the socket
1048                  * they originated from - MvS (miquels@drinkel.ow.org)
1049                  */
1050                 if ((ptype->dev == dev || !ptype->dev) &&
1051                     (ptype->af_packet_priv == NULL ||
1052                      (struct sock *)ptype->af_packet_priv != skb->sk)) {
1053                         struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1054                         if (!skb2)
1055                                 break;
1056
1057                         /* skb->nh should be correctly
1058                            set by sender, so that the second statement is
1059                            just protection against buggy protocols.
1060                          */
1061                         skb2->mac.raw = skb2->data;
1062
1063                         if (skb2->nh.raw < skb2->data ||
1064                             skb2->nh.raw > skb2->tail) {
1065                                 if (net_ratelimit())
1066                                         printk(KERN_CRIT "protocol %04x is "
1067                                                "buggy, dev %s\n",
1068                                                skb2->protocol, dev->name);
1069                                 skb2->nh.raw = skb2->data;
1070                         }
1071
1072                         skb2->h.raw = skb2->nh.raw;
1073                         skb2->pkt_type = PACKET_OUTGOING;
1074                         ptype->func(skb2, skb->dev, ptype, skb->dev);
1075                 }
1076         }
1077         rcu_read_unlock();
1078 }
1079
1080 /*
1081  * Invalidate hardware checksum when packet is to be mangled, and
1082  * complete checksum manually on outgoing path.
1083  */
1084 int skb_checksum_help(struct sk_buff *skb, int inward)
1085 {
1086         unsigned int csum;
1087         int ret = 0, offset = skb->h.raw - skb->data;
1088
1089         if (inward) {
1090                 skb->ip_summed = CHECKSUM_NONE;
1091                 goto out;
1092         }
1093
1094         if (skb_cloned(skb)) {
1095                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1096                 if (ret)
1097                         goto out;
1098         }
1099
1100         BUG_ON(offset > (int)skb->len);
1101         csum = skb_checksum(skb, offset, skb->len-offset, 0);
1102
1103         offset = skb->tail - skb->h.raw;
1104         BUG_ON(offset <= 0);
1105         BUG_ON(skb->csum + 2 > offset);
1106
1107         *(u16*)(skb->h.raw + skb->csum) = csum_fold(csum);
1108         skb->ip_summed = CHECKSUM_NONE;
1109 out:    
1110         return ret;
1111 }
1112
1113 /* Take action when hardware reception checksum errors are detected. */
1114 #ifdef CONFIG_BUG
1115 void netdev_rx_csum_fault(struct net_device *dev)
1116 {
1117         if (net_ratelimit()) {
1118                 printk(KERN_ERR "%s: hw csum failure.\n", 
1119                         dev ? dev->name : "<unknown>");
1120                 dump_stack();
1121         }
1122 }
1123 EXPORT_SYMBOL(netdev_rx_csum_fault);
1124 #endif
1125
1126 #ifdef CONFIG_HIGHMEM
1127 /* Actually, we should eliminate this check as soon as we know, that:
1128  * 1. IOMMU is present and allows to map all the memory.
1129  * 2. No high memory really exists on this machine.
1130  */
1131
1132 static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1133 {
1134         int i;
1135
1136         if (dev->features & NETIF_F_HIGHDMA)
1137                 return 0;
1138
1139         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1140                 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1141                         return 1;
1142
1143         return 0;
1144 }
1145 #else
1146 #define illegal_highdma(dev, skb)       (0)
1147 #endif
1148
1149 /* Keep head the same: replace data */
1150 int __skb_linearize(struct sk_buff *skb, gfp_t gfp_mask)
1151 {
1152         unsigned int size;
1153         u8 *data;
1154         long offset;
1155         struct skb_shared_info *ninfo;
1156         int headerlen = skb->data - skb->head;
1157         int expand = (skb->tail + skb->data_len) - skb->end;
1158
1159         if (skb_shared(skb))
1160                 BUG();
1161
1162         if (expand <= 0)
1163                 expand = 0;
1164
1165         size = skb->end - skb->head + expand;
1166         size = SKB_DATA_ALIGN(size);
1167         data = kmalloc(size + sizeof(struct skb_shared_info), gfp_mask);
1168         if (!data)
1169                 return -ENOMEM;
1170
1171         /* Copy entire thing */
1172         if (skb_copy_bits(skb, -headerlen, data, headerlen + skb->len))
1173                 BUG();
1174
1175         /* Set up shinfo */
1176         ninfo = (struct skb_shared_info*)(data + size);
1177         atomic_set(&ninfo->dataref, 1);
1178         ninfo->tso_size = skb_shinfo(skb)->tso_size;
1179         ninfo->tso_segs = skb_shinfo(skb)->tso_segs;
1180         ninfo->nr_frags = 0;
1181         ninfo->frag_list = NULL;
1182
1183         /* Offset between the two in bytes */
1184         offset = data - skb->head;
1185
1186         /* Free old data. */
1187         skb_release_data(skb);
1188
1189         skb->head = data;
1190         skb->end  = data + size;
1191
1192         /* Set up new pointers */
1193         skb->h.raw   += offset;
1194         skb->nh.raw  += offset;
1195         skb->mac.raw += offset;
1196         skb->tail    += offset;
1197         skb->data    += offset;
1198
1199         /* We are no longer a clone, even if we were. */
1200         skb->cloned    = 0;
1201
1202         skb->tail     += skb->data_len;
1203         skb->data_len  = 0;
1204         return 0;
1205 }
1206
1207 #define HARD_TX_LOCK(dev, cpu) {                        \
1208         if ((dev->features & NETIF_F_LLTX) == 0) {      \
1209                 spin_lock(&dev->xmit_lock);             \
1210                 dev->xmit_lock_owner = cpu;             \
1211         }                                               \
1212 }
1213
1214 #define HARD_TX_UNLOCK(dev) {                           \
1215         if ((dev->features & NETIF_F_LLTX) == 0) {      \
1216                 dev->xmit_lock_owner = -1;              \
1217                 spin_unlock(&dev->xmit_lock);           \
1218         }                                               \
1219 }
1220
1221 /**
1222  *      dev_queue_xmit - transmit a buffer
1223  *      @skb: buffer to transmit
1224  *
1225  *      Queue a buffer for transmission to a network device. The caller must
1226  *      have set the device and priority and built the buffer before calling
1227  *      this function. The function can be called from an interrupt.
1228  *
1229  *      A negative errno code is returned on a failure. A success does not
1230  *      guarantee the frame will be transmitted as it may be dropped due
1231  *      to congestion or traffic shaping.
1232  *
1233  * -----------------------------------------------------------------------------------
1234  *      I notice this method can also return errors from the queue disciplines,
1235  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
1236  *      be positive.
1237  *
1238  *      Regardless of the return value, the skb is consumed, so it is currently
1239  *      difficult to retry a send to this method.  (You can bump the ref count
1240  *      before sending to hold a reference for retry if you are careful.)
1241  *
1242  *      When calling this method, interrupts MUST be enabled.  This is because
1243  *      the BH enable code must have IRQs enabled so that it will not deadlock.
1244  *          --BLG
1245  */
1246
1247 int dev_queue_xmit(struct sk_buff *skb)
1248 {
1249         struct net_device *dev = skb->dev;
1250         struct Qdisc *q;
1251         int rc = -ENOMEM;
1252
1253         if (skb_shinfo(skb)->frag_list &&
1254             !(dev->features & NETIF_F_FRAGLIST) &&
1255             __skb_linearize(skb, GFP_ATOMIC))
1256                 goto out_kfree_skb;
1257
1258         /* Fragmented skb is linearized if device does not support SG,
1259          * or if at least one of fragments is in highmem and device
1260          * does not support DMA from it.
1261          */
1262         if (skb_shinfo(skb)->nr_frags &&
1263             (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1264             __skb_linearize(skb, GFP_ATOMIC))
1265                 goto out_kfree_skb;
1266
1267         /* If packet is not checksummed and device does not support
1268          * checksumming for this protocol, complete checksumming here.
1269          */
1270         if (skb->ip_summed == CHECKSUM_HW &&
1271             (!(dev->features & (NETIF_F_HW_CSUM | NETIF_F_NO_CSUM)) &&
1272              (!(dev->features & NETIF_F_IP_CSUM) ||
1273               skb->protocol != htons(ETH_P_IP))))
1274                 if (skb_checksum_help(skb, 0))
1275                         goto out_kfree_skb;
1276
1277         spin_lock_prefetch(&dev->queue_lock);
1278
1279         /* Disable soft irqs for various locks below. Also 
1280          * stops preemption for RCU. 
1281          */
1282         local_bh_disable(); 
1283
1284         /* Updates of qdisc are serialized by queue_lock. 
1285          * The struct Qdisc which is pointed to by qdisc is now a 
1286          * rcu structure - it may be accessed without acquiring 
1287          * a lock (but the structure may be stale.) The freeing of the
1288          * qdisc will be deferred until it's known that there are no 
1289          * more references to it.
1290          * 
1291          * If the qdisc has an enqueue function, we still need to 
1292          * hold the queue_lock before calling it, since queue_lock
1293          * also serializes access to the device queue.
1294          */
1295
1296         q = rcu_dereference(dev->qdisc);
1297 #ifdef CONFIG_NET_CLS_ACT
1298         skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1299 #endif
1300         if (q->enqueue) {
1301                 /* Grab device queue */
1302                 spin_lock(&dev->queue_lock);
1303
1304                 rc = q->enqueue(skb, q);
1305
1306                 qdisc_run(dev);
1307
1308                 spin_unlock(&dev->queue_lock);
1309                 rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
1310                 goto out;
1311         }
1312
1313         /* The device has no queue. Common case for software devices:
1314            loopback, all the sorts of tunnels...
1315
1316            Really, it is unlikely that xmit_lock protection is necessary here.
1317            (f.e. loopback and IP tunnels are clean ignoring statistics
1318            counters.)
1319            However, it is possible, that they rely on protection
1320            made by us here.
1321
1322            Check this and shot the lock. It is not prone from deadlocks.
1323            Either shot noqueue qdisc, it is even simpler 8)
1324          */
1325         if (dev->flags & IFF_UP) {
1326                 int cpu = smp_processor_id(); /* ok because BHs are off */
1327
1328                 if (dev->xmit_lock_owner != cpu) {
1329
1330                         HARD_TX_LOCK(dev, cpu);
1331
1332                         if (!netif_queue_stopped(dev)) {
1333                                 if (netdev_nit)
1334                                         dev_queue_xmit_nit(skb, dev);
1335
1336                                 rc = 0;
1337                                 if (!dev->hard_start_xmit(skb, dev)) {
1338                                         HARD_TX_UNLOCK(dev);
1339                                         goto out;
1340                                 }
1341                         }
1342                         HARD_TX_UNLOCK(dev);
1343                         if (net_ratelimit())
1344                                 printk(KERN_CRIT "Virtual device %s asks to "
1345                                        "queue packet!\n", dev->name);
1346                 } else {
1347                         /* Recursion is detected! It is possible,
1348                          * unfortunately */
1349                         if (net_ratelimit())
1350                                 printk(KERN_CRIT "Dead loop on virtual device "
1351                                        "%s, fix it urgently!\n", dev->name);
1352                 }
1353         }
1354
1355         rc = -ENETDOWN;
1356         local_bh_enable();
1357
1358 out_kfree_skb:
1359         kfree_skb(skb);
1360         return rc;
1361 out:
1362         local_bh_enable();
1363         return rc;
1364 }
1365
1366
1367 /*=======================================================================
1368                         Receiver routines
1369   =======================================================================*/
1370
1371 int netdev_max_backlog = 1000;
1372 int netdev_budget = 300;
1373 int weight_p = 64;            /* old backlog weight */
1374
1375 DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1376
1377
1378 /**
1379  *      netif_rx        -       post buffer to the network code
1380  *      @skb: buffer to post
1381  *
1382  *      This function receives a packet from a device driver and queues it for
1383  *      the upper (protocol) levels to process.  It always succeeds. The buffer
1384  *      may be dropped during processing for congestion control or by the
1385  *      protocol layers.
1386  *
1387  *      return values:
1388  *      NET_RX_SUCCESS  (no congestion)
1389  *      NET_RX_CN_LOW   (low congestion)
1390  *      NET_RX_CN_MOD   (moderate congestion)
1391  *      NET_RX_CN_HIGH  (high congestion)
1392  *      NET_RX_DROP     (packet was dropped)
1393  *
1394  */
1395
1396 int netif_rx(struct sk_buff *skb)
1397 {
1398         struct softnet_data *queue;
1399         unsigned long flags;
1400
1401         /* if netpoll wants it, pretend we never saw it */
1402         if (netpoll_rx(skb))
1403                 return NET_RX_DROP;
1404
1405         if (!skb->tstamp.off_sec)
1406                 net_timestamp(skb);
1407
1408         /*
1409          * The code is rearranged so that the path is the most
1410          * short when CPU is congested, but is still operating.
1411          */
1412         local_irq_save(flags);
1413         queue = &__get_cpu_var(softnet_data);
1414
1415         __get_cpu_var(netdev_rx_stat).total++;
1416         if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1417                 if (queue->input_pkt_queue.qlen) {
1418 enqueue:
1419                         dev_hold(skb->dev);
1420                         __skb_queue_tail(&queue->input_pkt_queue, skb);
1421                         local_irq_restore(flags);
1422                         return NET_RX_SUCCESS;
1423                 }
1424
1425                 netif_rx_schedule(&queue->backlog_dev);
1426                 goto enqueue;
1427         }
1428
1429         __get_cpu_var(netdev_rx_stat).dropped++;
1430         local_irq_restore(flags);
1431
1432         kfree_skb(skb);
1433         return NET_RX_DROP;
1434 }
1435
1436 int netif_rx_ni(struct sk_buff *skb)
1437 {
1438         int err;
1439
1440         preempt_disable();
1441         err = netif_rx(skb);
1442         if (local_softirq_pending())
1443                 do_softirq();
1444         preempt_enable();
1445
1446         return err;
1447 }
1448
1449 EXPORT_SYMBOL(netif_rx_ni);
1450
1451 static inline struct net_device *skb_bond(struct sk_buff *skb)
1452 {
1453         struct net_device *dev = skb->dev;
1454
1455         if (dev->master) {
1456                 /*
1457                  * On bonding slaves other than the currently active
1458                  * slave, suppress duplicates except for 802.3ad
1459                  * ETH_P_SLOW and alb non-mcast/bcast.
1460                  */
1461                 if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
1462                         if (dev->master->priv_flags & IFF_MASTER_ALB) {
1463                                 if (skb->pkt_type != PACKET_BROADCAST &&
1464                                     skb->pkt_type != PACKET_MULTICAST)
1465                                         goto keep;
1466                         }
1467
1468                         if (dev->master->priv_flags & IFF_MASTER_8023AD &&
1469                             skb->protocol == __constant_htons(ETH_P_SLOW))
1470                                 goto keep;
1471                 
1472                         kfree_skb(skb);
1473                         return NULL;
1474                 }
1475 keep:
1476                 skb->dev = dev->master;
1477         }
1478
1479         return dev;
1480 }
1481
1482 static void net_tx_action(struct softirq_action *h)
1483 {
1484         struct softnet_data *sd = &__get_cpu_var(softnet_data);
1485
1486         if (sd->completion_queue) {
1487                 struct sk_buff *clist;
1488
1489                 local_irq_disable();
1490                 clist = sd->completion_queue;
1491                 sd->completion_queue = NULL;
1492                 local_irq_enable();
1493
1494                 while (clist) {
1495                         struct sk_buff *skb = clist;
1496                         clist = clist->next;
1497
1498                         BUG_TRAP(!atomic_read(&skb->users));
1499                         __kfree_skb(skb);
1500                 }
1501         }
1502
1503         if (sd->output_queue) {
1504                 struct net_device *head;
1505
1506                 local_irq_disable();
1507                 head = sd->output_queue;
1508                 sd->output_queue = NULL;
1509                 local_irq_enable();
1510
1511                 while (head) {
1512                         struct net_device *dev = head;
1513                         head = head->next_sched;
1514
1515                         smp_mb__before_clear_bit();
1516                         clear_bit(__LINK_STATE_SCHED, &dev->state);
1517
1518                         if (spin_trylock(&dev->queue_lock)) {
1519                                 qdisc_run(dev);
1520                                 spin_unlock(&dev->queue_lock);
1521                         } else {
1522                                 netif_schedule(dev);
1523                         }
1524                 }
1525         }
1526 }
1527
1528 static __inline__ int deliver_skb(struct sk_buff *skb,
1529                                   struct packet_type *pt_prev,
1530                                   struct net_device *orig_dev)
1531 {
1532         atomic_inc(&skb->users);
1533         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1534 }
1535
1536 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
1537 int (*br_handle_frame_hook)(struct net_bridge_port *p, struct sk_buff **pskb);
1538 struct net_bridge;
1539 struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
1540                                                 unsigned char *addr);
1541 void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent);
1542
1543 static __inline__ int handle_bridge(struct sk_buff **pskb,
1544                                     struct packet_type **pt_prev, int *ret,
1545                                     struct net_device *orig_dev)
1546 {
1547         struct net_bridge_port *port;
1548
1549         if ((*pskb)->pkt_type == PACKET_LOOPBACK ||
1550             (port = rcu_dereference((*pskb)->dev->br_port)) == NULL)
1551                 return 0;
1552
1553         if (*pt_prev) {
1554                 *ret = deliver_skb(*pskb, *pt_prev, orig_dev);
1555                 *pt_prev = NULL;
1556         } 
1557         
1558         return br_handle_frame_hook(port, pskb);
1559 }
1560 #else
1561 #define handle_bridge(skb, pt_prev, ret, orig_dev)      (0)
1562 #endif
1563
1564 #ifdef CONFIG_NET_CLS_ACT
1565 /* TODO: Maybe we should just force sch_ingress to be compiled in
1566  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
1567  * a compare and 2 stores extra right now if we dont have it on
1568  * but have CONFIG_NET_CLS_ACT
1569  * NOTE: This doesnt stop any functionality; if you dont have 
1570  * the ingress scheduler, you just cant add policies on ingress.
1571  *
1572  */
1573 static int ing_filter(struct sk_buff *skb) 
1574 {
1575         struct Qdisc *q;
1576         struct net_device *dev = skb->dev;
1577         int result = TC_ACT_OK;
1578         
1579         if (dev->qdisc_ingress) {
1580                 __u32 ttl = (__u32) G_TC_RTTL(skb->tc_verd);
1581                 if (MAX_RED_LOOP < ttl++) {
1582                         printk("Redir loop detected Dropping packet (%s->%s)\n",
1583                                 skb->input_dev->name, skb->dev->name);
1584                         return TC_ACT_SHOT;
1585                 }
1586
1587                 skb->tc_verd = SET_TC_RTTL(skb->tc_verd,ttl);
1588
1589                 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_INGRESS);
1590
1591                 spin_lock(&dev->ingress_lock);
1592                 if ((q = dev->qdisc_ingress) != NULL)
1593                         result = q->enqueue(skb, q);
1594                 spin_unlock(&dev->ingress_lock);
1595
1596         }
1597
1598         return result;
1599 }
1600 #endif
1601
1602 int netif_receive_skb(struct sk_buff *skb)
1603 {
1604         struct packet_type *ptype, *pt_prev;
1605         struct net_device *orig_dev;
1606         int ret = NET_RX_DROP;
1607         unsigned short type;
1608
1609         /* if we've gotten here through NAPI, check netpoll */
1610         if (skb->dev->poll && netpoll_rx(skb))
1611                 return NET_RX_DROP;
1612
1613         if (!skb->tstamp.off_sec)
1614                 net_timestamp(skb);
1615
1616         if (!skb->input_dev)
1617                 skb->input_dev = skb->dev;
1618
1619         orig_dev = skb_bond(skb);
1620
1621         if (!orig_dev)
1622                 return NET_RX_DROP;
1623
1624         __get_cpu_var(netdev_rx_stat).total++;
1625
1626         skb->h.raw = skb->nh.raw = skb->data;
1627         skb->mac_len = skb->nh.raw - skb->mac.raw;
1628
1629         pt_prev = NULL;
1630
1631         rcu_read_lock();
1632
1633 #ifdef CONFIG_NET_CLS_ACT
1634         if (skb->tc_verd & TC_NCLS) {
1635                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
1636                 goto ncls;
1637         }
1638 #endif
1639
1640         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1641                 if (!ptype->dev || ptype->dev == skb->dev) {
1642                         if (pt_prev) 
1643                                 ret = deliver_skb(skb, pt_prev, orig_dev);
1644                         pt_prev = ptype;
1645                 }
1646         }
1647
1648 #ifdef CONFIG_NET_CLS_ACT
1649         if (pt_prev) {
1650                 ret = deliver_skb(skb, pt_prev, orig_dev);
1651                 pt_prev = NULL; /* noone else should process this after*/
1652         } else {
1653                 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
1654         }
1655
1656         ret = ing_filter(skb);
1657
1658         if (ret == TC_ACT_SHOT || (ret == TC_ACT_STOLEN)) {
1659                 kfree_skb(skb);
1660                 goto out;
1661         }
1662
1663         skb->tc_verd = 0;
1664 ncls:
1665 #endif
1666
1667         handle_diverter(skb);
1668
1669         if (handle_bridge(&skb, &pt_prev, &ret, orig_dev))
1670                 goto out;
1671
1672         type = skb->protocol;
1673         list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type)&15], list) {
1674                 if (ptype->type == type &&
1675                     (!ptype->dev || ptype->dev == skb->dev)) {
1676                         if (pt_prev) 
1677                                 ret = deliver_skb(skb, pt_prev, orig_dev);
1678                         pt_prev = ptype;
1679                 }
1680         }
1681
1682         if (pt_prev) {
1683                 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
1684         } else {
1685                 kfree_skb(skb);
1686                 /* Jamal, now you will not able to escape explaining
1687                  * me how you were going to use this. :-)
1688                  */
1689                 ret = NET_RX_DROP;
1690         }
1691
1692 out:
1693         rcu_read_unlock();
1694         return ret;
1695 }
1696
1697 static int process_backlog(struct net_device *backlog_dev, int *budget)
1698 {
1699         int work = 0;
1700         int quota = min(backlog_dev->quota, *budget);
1701         struct softnet_data *queue = &__get_cpu_var(softnet_data);
1702         unsigned long start_time = jiffies;
1703
1704         backlog_dev->weight = weight_p;
1705         for (;;) {
1706                 struct sk_buff *skb;
1707                 struct net_device *dev;
1708
1709                 local_irq_disable();
1710                 skb = __skb_dequeue(&queue->input_pkt_queue);
1711                 if (!skb)
1712                         goto job_done;
1713                 local_irq_enable();
1714
1715                 dev = skb->dev;
1716
1717                 netif_receive_skb(skb);
1718
1719                 dev_put(dev);
1720
1721                 work++;
1722
1723                 if (work >= quota || jiffies - start_time > 1)
1724                         break;
1725
1726         }
1727
1728         backlog_dev->quota -= work;
1729         *budget -= work;
1730         return -1;
1731
1732 job_done:
1733         backlog_dev->quota -= work;
1734         *budget -= work;
1735
1736         list_del(&backlog_dev->poll_list);
1737         smp_mb__before_clear_bit();
1738         netif_poll_enable(backlog_dev);
1739
1740         local_irq_enable();
1741         return 0;
1742 }
1743
1744 static void net_rx_action(struct softirq_action *h)
1745 {
1746         struct softnet_data *queue = &__get_cpu_var(softnet_data);
1747         unsigned long start_time = jiffies;
1748         int budget = netdev_budget;
1749         void *have;
1750
1751         local_irq_disable();
1752
1753         while (!list_empty(&queue->poll_list)) {
1754                 struct net_device *dev;
1755
1756                 if (budget <= 0 || jiffies - start_time > 1)
1757                         goto softnet_break;
1758
1759                 local_irq_enable();
1760
1761                 dev = list_entry(queue->poll_list.next,
1762                                  struct net_device, poll_list);
1763                 have = netpoll_poll_lock(dev);
1764
1765                 if (dev->quota <= 0 || dev->poll(dev, &budget)) {
1766                         netpoll_poll_unlock(have);
1767                         local_irq_disable();
1768                         list_move_tail(&dev->poll_list, &queue->poll_list);
1769                         if (dev->quota < 0)
1770                                 dev->quota += dev->weight;
1771                         else
1772                                 dev->quota = dev->weight;
1773                 } else {
1774                         netpoll_poll_unlock(have);
1775                         dev_put(dev);
1776                         local_irq_disable();
1777                 }
1778         }
1779 out:
1780         local_irq_enable();
1781         return;
1782
1783 softnet_break:
1784         __get_cpu_var(netdev_rx_stat).time_squeeze++;
1785         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
1786         goto out;
1787 }
1788
1789 static gifconf_func_t * gifconf_list [NPROTO];
1790
1791 /**
1792  *      register_gifconf        -       register a SIOCGIF handler
1793  *      @family: Address family
1794  *      @gifconf: Function handler
1795  *
1796  *      Register protocol dependent address dumping routines. The handler
1797  *      that is passed must not be freed or reused until it has been replaced
1798  *      by another handler.
1799  */
1800 int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
1801 {
1802         if (family >= NPROTO)
1803                 return -EINVAL;
1804         gifconf_list[family] = gifconf;
1805         return 0;
1806 }
1807
1808
1809 /*
1810  *      Map an interface index to its name (SIOCGIFNAME)
1811  */
1812
1813 /*
1814  *      We need this ioctl for efficient implementation of the
1815  *      if_indextoname() function required by the IPv6 API.  Without
1816  *      it, we would have to search all the interfaces to find a
1817  *      match.  --pb
1818  */
1819
1820 static int dev_ifname(struct ifreq __user *arg)
1821 {
1822         struct net_device *dev;
1823         struct ifreq ifr;
1824
1825         /*
1826          *      Fetch the caller's info block.
1827          */
1828
1829         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
1830                 return -EFAULT;
1831
1832         read_lock(&dev_base_lock);
1833         dev = __dev_get_by_index(ifr.ifr_ifindex);
1834         if (!dev) {
1835                 read_unlock(&dev_base_lock);
1836                 return -ENODEV;
1837         }
1838
1839         strcpy(ifr.ifr_name, dev->name);
1840         read_unlock(&dev_base_lock);
1841
1842         if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
1843                 return -EFAULT;
1844         return 0;
1845 }
1846
1847 /*
1848  *      Perform a SIOCGIFCONF call. This structure will change
1849  *      size eventually, and there is nothing I can do about it.
1850  *      Thus we will need a 'compatibility mode'.
1851  */
1852
1853 static int dev_ifconf(char __user *arg)
1854 {
1855         struct ifconf ifc;
1856         struct net_device *dev;
1857         char __user *pos;
1858         int len;
1859         int total;
1860         int i;
1861
1862         /*
1863          *      Fetch the caller's info block.
1864          */
1865
1866         if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
1867                 return -EFAULT;
1868
1869         pos = ifc.ifc_buf;
1870         len = ifc.ifc_len;
1871
1872         /*
1873          *      Loop over the interfaces, and write an info block for each.
1874          */
1875
1876         total = 0;
1877         for (dev = dev_base; dev; dev = dev->next) {
1878                 for (i = 0; i < NPROTO; i++) {
1879                         if (gifconf_list[i]) {
1880                                 int done;
1881                                 if (!pos)
1882                                         done = gifconf_list[i](dev, NULL, 0);
1883                                 else
1884                                         done = gifconf_list[i](dev, pos + total,
1885                                                                len - total);
1886                                 if (done < 0)
1887                                         return -EFAULT;
1888                                 total += done;
1889                         }
1890                 }
1891         }
1892
1893         /*
1894          *      All done.  Write the updated control block back to the caller.
1895          */
1896         ifc.ifc_len = total;
1897
1898         /*
1899          *      Both BSD and Solaris return 0 here, so we do too.
1900          */
1901         return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
1902 }
1903
1904 #ifdef CONFIG_PROC_FS
1905 /*
1906  *      This is invoked by the /proc filesystem handler to display a device
1907  *      in detail.
1908  */
1909 static __inline__ struct net_device *dev_get_idx(loff_t pos)
1910 {
1911         struct net_device *dev;
1912         loff_t i;
1913
1914         for (i = 0, dev = dev_base; dev && i < pos; ++i, dev = dev->next);
1915
1916         return i == pos ? dev : NULL;
1917 }
1918
1919 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
1920 {
1921         read_lock(&dev_base_lock);
1922         return *pos ? dev_get_idx(*pos - 1) : SEQ_START_TOKEN;
1923 }
1924
1925 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1926 {
1927         ++*pos;
1928         return v == SEQ_START_TOKEN ? dev_base : ((struct net_device *)v)->next;
1929 }
1930
1931 void dev_seq_stop(struct seq_file *seq, void *v)
1932 {
1933         read_unlock(&dev_base_lock);
1934 }
1935
1936 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
1937 {
1938         if (dev->get_stats) {
1939                 struct net_device_stats *stats = dev->get_stats(dev);
1940
1941                 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
1942                                 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
1943                            dev->name, stats->rx_bytes, stats->rx_packets,
1944                            stats->rx_errors,
1945                            stats->rx_dropped + stats->rx_missed_errors,
1946                            stats->rx_fifo_errors,
1947                            stats->rx_length_errors + stats->rx_over_errors +
1948                              stats->rx_crc_errors + stats->rx_frame_errors,
1949                            stats->rx_compressed, stats->multicast,
1950                            stats->tx_bytes, stats->tx_packets,
1951                            stats->tx_errors, stats->tx_dropped,
1952                            stats->tx_fifo_errors, stats->collisions,
1953                            stats->tx_carrier_errors +
1954                              stats->tx_aborted_errors +
1955                              stats->tx_window_errors +
1956                              stats->tx_heartbeat_errors,
1957                            stats->tx_compressed);
1958         } else
1959                 seq_printf(seq, "%6s: No statistics available.\n", dev->name);
1960 }
1961
1962 /*
1963  *      Called from the PROCfs module. This now uses the new arbitrary sized
1964  *      /proc/net interface to create /proc/net/dev
1965  */
1966 static int dev_seq_show(struct seq_file *seq, void *v)
1967 {
1968         if (v == SEQ_START_TOKEN)
1969                 seq_puts(seq, "Inter-|   Receive                            "
1970                               "                    |  Transmit\n"
1971                               " face |bytes    packets errs drop fifo frame "
1972                               "compressed multicast|bytes    packets errs "
1973                               "drop fifo colls carrier compressed\n");
1974         else
1975                 dev_seq_printf_stats(seq, v);
1976         return 0;
1977 }
1978
1979 static struct netif_rx_stats *softnet_get_online(loff_t *pos)
1980 {
1981         struct netif_rx_stats *rc = NULL;
1982
1983         while (*pos < NR_CPUS)
1984                 if (cpu_online(*pos)) {
1985                         rc = &per_cpu(netdev_rx_stat, *pos);
1986                         break;
1987                 } else
1988                         ++*pos;
1989         return rc;
1990 }
1991
1992 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
1993 {
1994         return softnet_get_online(pos);
1995 }
1996
1997 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1998 {
1999         ++*pos;
2000         return softnet_get_online(pos);
2001 }
2002
2003 static void softnet_seq_stop(struct seq_file *seq, void *v)
2004 {
2005 }
2006
2007 static int softnet_seq_show(struct seq_file *seq, void *v)
2008 {
2009         struct netif_rx_stats *s = v;
2010
2011         seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
2012                    s->total, s->dropped, s->time_squeeze, 0,
2013                    0, 0, 0, 0, /* was fastroute */
2014                    s->cpu_collision );
2015         return 0;
2016 }
2017
2018 static struct seq_operations dev_seq_ops = {
2019         .start = dev_seq_start,
2020         .next  = dev_seq_next,
2021         .stop  = dev_seq_stop,
2022         .show  = dev_seq_show,
2023 };
2024
2025 static int dev_seq_open(struct inode *inode, struct file *file)
2026 {
2027         return seq_open(file, &dev_seq_ops);
2028 }
2029
2030 static struct file_operations dev_seq_fops = {
2031         .owner   = THIS_MODULE,
2032         .open    = dev_seq_open,
2033         .read    = seq_read,
2034         .llseek  = seq_lseek,
2035         .release = seq_release,
2036 };
2037
2038 static struct seq_operations softnet_seq_ops = {
2039         .start = softnet_seq_start,
2040         .next  = softnet_seq_next,
2041         .stop  = softnet_seq_stop,
2042         .show  = softnet_seq_show,
2043 };
2044
2045 static int softnet_seq_open(struct inode *inode, struct file *file)
2046 {
2047         return seq_open(file, &softnet_seq_ops);
2048 }
2049
2050 static struct file_operations softnet_seq_fops = {
2051         .owner   = THIS_MODULE,
2052         .open    = softnet_seq_open,
2053         .read    = seq_read,
2054         .llseek  = seq_lseek,
2055         .release = seq_release,
2056 };
2057
2058 #ifdef CONFIG_WIRELESS_EXT
2059 extern int wireless_proc_init(void);
2060 #else
2061 #define wireless_proc_init() 0
2062 #endif
2063
2064 static int __init dev_proc_init(void)
2065 {
2066         int rc = -ENOMEM;
2067
2068         if (!proc_net_fops_create("dev", S_IRUGO, &dev_seq_fops))
2069                 goto out;
2070         if (!proc_net_fops_create("softnet_stat", S_IRUGO, &softnet_seq_fops))
2071                 goto out_dev;
2072         if (wireless_proc_init())
2073                 goto out_softnet;
2074         rc = 0;
2075 out:
2076         return rc;
2077 out_softnet:
2078         proc_net_remove("softnet_stat");
2079 out_dev:
2080         proc_net_remove("dev");
2081         goto out;
2082 }
2083 #else
2084 #define dev_proc_init() 0
2085 #endif  /* CONFIG_PROC_FS */
2086
2087
2088 /**
2089  *      netdev_set_master       -       set up master/slave pair
2090  *      @slave: slave device
2091  *      @master: new master device
2092  *
2093  *      Changes the master device of the slave. Pass %NULL to break the
2094  *      bonding. The caller must hold the RTNL semaphore. On a failure
2095  *      a negative errno code is returned. On success the reference counts
2096  *      are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2097  *      function returns zero.
2098  */
2099 int netdev_set_master(struct net_device *slave, struct net_device *master)
2100 {
2101         struct net_device *old = slave->master;
2102
2103         ASSERT_RTNL();
2104
2105         if (master) {
2106                 if (old)
2107                         return -EBUSY;
2108                 dev_hold(master);
2109         }
2110
2111         slave->master = master;
2112         
2113         synchronize_net();
2114
2115         if (old)
2116                 dev_put(old);
2117
2118         if (master)
2119                 slave->flags |= IFF_SLAVE;
2120         else
2121                 slave->flags &= ~IFF_SLAVE;
2122
2123         rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2124         return 0;
2125 }
2126
2127 /**
2128  *      dev_set_promiscuity     - update promiscuity count on a device
2129  *      @dev: device
2130  *      @inc: modifier
2131  *
2132  *      Add or remove promsicuity from a device. While the count in the device
2133  *      remains above zero the interface remains promiscuous. Once it hits zero
2134  *      the device reverts back to normal filtering operation. A negative inc
2135  *      value is used to drop promiscuity on the device.
2136  */
2137 void dev_set_promiscuity(struct net_device *dev, int inc)
2138 {
2139         unsigned short old_flags = dev->flags;
2140
2141         if ((dev->promiscuity += inc) == 0)
2142                 dev->flags &= ~IFF_PROMISC;
2143         else
2144                 dev->flags |= IFF_PROMISC;
2145         if (dev->flags != old_flags) {
2146                 dev_mc_upload(dev);
2147                 printk(KERN_INFO "device %s %s promiscuous mode\n",
2148                        dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
2149                                                                "left");
2150         }
2151 }
2152
2153 /**
2154  *      dev_set_allmulti        - update allmulti count on a device
2155  *      @dev: device
2156  *      @inc: modifier
2157  *
2158  *      Add or remove reception of all multicast frames to a device. While the
2159  *      count in the device remains above zero the interface remains listening
2160  *      to all interfaces. Once it hits zero the device reverts back to normal
2161  *      filtering operation. A negative @inc value is used to drop the counter
2162  *      when releasing a resource needing all multicasts.
2163  */
2164
2165 void dev_set_allmulti(struct net_device *dev, int inc)
2166 {
2167         unsigned short old_flags = dev->flags;
2168
2169         dev->flags |= IFF_ALLMULTI;
2170         if ((dev->allmulti += inc) == 0)
2171                 dev->flags &= ~IFF_ALLMULTI;
2172         if (dev->flags ^ old_flags)
2173                 dev_mc_upload(dev);
2174 }
2175
2176 unsigned dev_get_flags(const struct net_device *dev)
2177 {
2178         unsigned flags;
2179
2180         flags = (dev->flags & ~(IFF_PROMISC |
2181                                 IFF_ALLMULTI |
2182                                 IFF_RUNNING |
2183                                 IFF_LOWER_UP |
2184                                 IFF_DORMANT)) |
2185                 (dev->gflags & (IFF_PROMISC |
2186                                 IFF_ALLMULTI));
2187
2188         if (netif_running(dev)) {
2189                 if (netif_oper_up(dev))
2190                         flags |= IFF_RUNNING;
2191                 if (netif_carrier_ok(dev))
2192                         flags |= IFF_LOWER_UP;
2193                 if (netif_dormant(dev))
2194                         flags |= IFF_DORMANT;
2195         }
2196
2197         return flags;
2198 }
2199
2200 int dev_change_flags(struct net_device *dev, unsigned flags)
2201 {
2202         int ret;
2203         int old_flags = dev->flags;
2204
2205         /*
2206          *      Set the flags on our device.
2207          */
2208
2209         dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
2210                                IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
2211                                IFF_AUTOMEDIA)) |
2212                      (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
2213                                     IFF_ALLMULTI));
2214
2215         /*
2216          *      Load in the correct multicast list now the flags have changed.
2217          */
2218
2219         dev_mc_upload(dev);
2220
2221         /*
2222          *      Have we downed the interface. We handle IFF_UP ourselves
2223          *      according to user attempts to set it, rather than blindly
2224          *      setting it.
2225          */
2226
2227         ret = 0;
2228         if ((old_flags ^ flags) & IFF_UP) {     /* Bit is different  ? */
2229                 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
2230
2231                 if (!ret)
2232                         dev_mc_upload(dev);
2233         }
2234
2235         if (dev->flags & IFF_UP &&
2236             ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
2237                                           IFF_VOLATILE)))
2238                 notifier_call_chain(&netdev_chain, NETDEV_CHANGE, dev);
2239
2240         if ((flags ^ dev->gflags) & IFF_PROMISC) {
2241                 int inc = (flags & IFF_PROMISC) ? +1 : -1;
2242                 dev->gflags ^= IFF_PROMISC;
2243                 dev_set_promiscuity(dev, inc);
2244         }
2245
2246         /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
2247            is important. Some (broken) drivers set IFF_PROMISC, when
2248            IFF_ALLMULTI is requested not asking us and not reporting.
2249          */
2250         if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
2251                 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
2252                 dev->gflags ^= IFF_ALLMULTI;
2253                 dev_set_allmulti(dev, inc);
2254         }
2255
2256         if (old_flags ^ dev->flags)
2257                 rtmsg_ifinfo(RTM_NEWLINK, dev, old_flags ^ dev->flags);
2258
2259         return ret;
2260 }
2261
2262 int dev_set_mtu(struct net_device *dev, int new_mtu)
2263 {
2264         int err;
2265
2266         if (new_mtu == dev->mtu)
2267                 return 0;
2268
2269         /*      MTU must be positive.    */
2270         if (new_mtu < 0)
2271                 return -EINVAL;
2272
2273         if (!netif_device_present(dev))
2274                 return -ENODEV;
2275
2276         err = 0;
2277         if (dev->change_mtu)
2278                 err = dev->change_mtu(dev, new_mtu);
2279         else
2280                 dev->mtu = new_mtu;
2281         if (!err && dev->flags & IFF_UP)
2282                 notifier_call_chain(&netdev_chain,
2283                                     NETDEV_CHANGEMTU, dev);
2284         return err;
2285 }
2286
2287 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
2288 {
2289         int err;
2290
2291         if (!dev->set_mac_address)
2292                 return -EOPNOTSUPP;
2293         if (sa->sa_family != dev->type)
2294                 return -EINVAL;
2295         if (!netif_device_present(dev))
2296                 return -ENODEV;
2297         err = dev->set_mac_address(dev, sa);
2298         if (!err)
2299                 notifier_call_chain(&netdev_chain, NETDEV_CHANGEADDR, dev);
2300         return err;
2301 }
2302
2303 /*
2304  *      Perform the SIOCxIFxxx calls.
2305  */
2306 static int dev_ifsioc(struct ifreq *ifr, unsigned int cmd)
2307 {
2308         int err;
2309         struct net_device *dev = __dev_get_by_name(ifr->ifr_name);
2310
2311         if (!dev)
2312                 return -ENODEV;
2313
2314         switch (cmd) {
2315                 case SIOCGIFFLAGS:      /* Get interface flags */
2316                         ifr->ifr_flags = dev_get_flags(dev);
2317                         return 0;
2318
2319                 case SIOCSIFFLAGS:      /* Set interface flags */
2320                         return dev_change_flags(dev, ifr->ifr_flags);
2321
2322                 case SIOCGIFMETRIC:     /* Get the metric on the interface
2323                                            (currently unused) */
2324                         ifr->ifr_metric = 0;
2325                         return 0;
2326
2327                 case SIOCSIFMETRIC:     /* Set the metric on the interface
2328                                            (currently unused) */
2329                         return -EOPNOTSUPP;
2330
2331                 case SIOCGIFMTU:        /* Get the MTU of a device */
2332                         ifr->ifr_mtu = dev->mtu;
2333                         return 0;
2334
2335                 case SIOCSIFMTU:        /* Set the MTU of a device */
2336                         return dev_set_mtu(dev, ifr->ifr_mtu);
2337
2338                 case SIOCGIFHWADDR:
2339                         if (!dev->addr_len)
2340                                 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
2341                         else
2342                                 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
2343                                        min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
2344                         ifr->ifr_hwaddr.sa_family = dev->type;
2345                         return 0;
2346
2347                 case SIOCSIFHWADDR:
2348                         return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
2349
2350                 case SIOCSIFHWBROADCAST:
2351                         if (ifr->ifr_hwaddr.sa_family != dev->type)
2352                                 return -EINVAL;
2353                         memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
2354                                min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
2355                         notifier_call_chain(&netdev_chain,
2356                                             NETDEV_CHANGEADDR, dev);
2357                         return 0;
2358
2359                 case SIOCGIFMAP:
2360                         ifr->ifr_map.mem_start = dev->mem_start;
2361                         ifr->ifr_map.mem_end   = dev->mem_end;
2362                         ifr->ifr_map.base_addr = dev->base_addr;
2363                         ifr->ifr_map.irq       = dev->irq;
2364                         ifr->ifr_map.dma       = dev->dma;
2365                         ifr->ifr_map.port      = dev->if_port;
2366                         return 0;
2367
2368                 case SIOCSIFMAP:
2369                         if (dev->set_config) {
2370                                 if (!netif_device_present(dev))
2371                                         return -ENODEV;
2372                                 return dev->set_config(dev, &ifr->ifr_map);
2373                         }
2374                         return -EOPNOTSUPP;
2375
2376                 case SIOCADDMULTI:
2377                         if (!dev->set_multicast_list ||
2378                             ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
2379                                 return -EINVAL;
2380                         if (!netif_device_present(dev))
2381                                 return -ENODEV;
2382                         return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
2383                                           dev->addr_len, 1);
2384
2385                 case SIOCDELMULTI:
2386                         if (!dev->set_multicast_list ||
2387                             ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
2388                                 return -EINVAL;
2389                         if (!netif_device_present(dev))
2390                                 return -ENODEV;
2391                         return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
2392                                              dev->addr_len, 1);
2393
2394                 case SIOCGIFINDEX:
2395                         ifr->ifr_ifindex = dev->ifindex;
2396                         return 0;
2397
2398                 case SIOCGIFTXQLEN:
2399                         ifr->ifr_qlen = dev->tx_queue_len;
2400                         return 0;
2401
2402                 case SIOCSIFTXQLEN:
2403                         if (ifr->ifr_qlen < 0)
2404                                 return -EINVAL;
2405                         dev->tx_queue_len = ifr->ifr_qlen;
2406                         return 0;
2407
2408                 case SIOCSIFNAME:
2409                         ifr->ifr_newname[IFNAMSIZ-1] = '\0';
2410                         return dev_change_name(dev, ifr->ifr_newname);
2411
2412                 /*
2413                  *      Unknown or private ioctl
2414                  */
2415
2416                 default:
2417                         if ((cmd >= SIOCDEVPRIVATE &&
2418                             cmd <= SIOCDEVPRIVATE + 15) ||
2419                             cmd == SIOCBONDENSLAVE ||
2420                             cmd == SIOCBONDRELEASE ||
2421                             cmd == SIOCBONDSETHWADDR ||
2422                             cmd == SIOCBONDSLAVEINFOQUERY ||
2423                             cmd == SIOCBONDINFOQUERY ||
2424                             cmd == SIOCBONDCHANGEACTIVE ||
2425                             cmd == SIOCGMIIPHY ||
2426                             cmd == SIOCGMIIREG ||
2427                             cmd == SIOCSMIIREG ||
2428                             cmd == SIOCBRADDIF ||
2429                             cmd == SIOCBRDELIF ||
2430                             cmd == SIOCWANDEV) {
2431                                 err = -EOPNOTSUPP;
2432                                 if (dev->do_ioctl) {
2433                                         if (netif_device_present(dev))
2434                                                 err = dev->do_ioctl(dev, ifr,
2435                                                                     cmd);
2436                                         else
2437                                                 err = -ENODEV;
2438                                 }
2439                         } else
2440                                 err = -EINVAL;
2441
2442         }
2443         return err;
2444 }
2445
2446 /*
2447  *      This function handles all "interface"-type I/O control requests. The actual
2448  *      'doing' part of this is dev_ifsioc above.
2449  */
2450
2451 /**
2452  *      dev_ioctl       -       network device ioctl
2453  *      @cmd: command to issue
2454  *      @arg: pointer to a struct ifreq in user space
2455  *
2456  *      Issue ioctl functions to devices. This is normally called by the
2457  *      user space syscall interfaces but can sometimes be useful for
2458  *      other purposes. The return value is the return from the syscall if
2459  *      positive or a negative errno code on error.
2460  */
2461
2462 int dev_ioctl(unsigned int cmd, void __user *arg)
2463 {
2464         struct ifreq ifr;
2465         int ret;
2466         char *colon;
2467
2468         /* One special case: SIOCGIFCONF takes ifconf argument
2469            and requires shared lock, because it sleeps writing
2470            to user space.
2471          */
2472
2473         if (cmd == SIOCGIFCONF) {
2474                 rtnl_lock();
2475                 ret = dev_ifconf((char __user *) arg);
2476                 rtnl_unlock();
2477                 return ret;
2478         }
2479         if (cmd == SIOCGIFNAME)
2480                 return dev_ifname((struct ifreq __user *)arg);
2481
2482         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2483                 return -EFAULT;
2484
2485         ifr.ifr_name[IFNAMSIZ-1] = 0;
2486
2487         colon = strchr(ifr.ifr_name, ':');
2488         if (colon)
2489                 *colon = 0;
2490
2491         /*
2492          *      See which interface the caller is talking about.
2493          */
2494
2495         switch (cmd) {
2496                 /*
2497                  *      These ioctl calls:
2498                  *      - can be done by all.
2499                  *      - atomic and do not require locking.
2500                  *      - return a value
2501                  */
2502                 case SIOCGIFFLAGS:
2503                 case SIOCGIFMETRIC:
2504                 case SIOCGIFMTU:
2505                 case SIOCGIFHWADDR:
2506                 case SIOCGIFSLAVE:
2507                 case SIOCGIFMAP:
2508                 case SIOCGIFINDEX:
2509                 case SIOCGIFTXQLEN:
2510                         dev_load(ifr.ifr_name);
2511                         read_lock(&dev_base_lock);
2512                         ret = dev_ifsioc(&ifr, cmd);
2513                         read_unlock(&dev_base_lock);
2514                         if (!ret) {
2515                                 if (colon)
2516                                         *colon = ':';
2517                                 if (copy_to_user(arg, &ifr,
2518                                                  sizeof(struct ifreq)))
2519                                         ret = -EFAULT;
2520                         }
2521                         return ret;
2522
2523                 case SIOCETHTOOL:
2524                         dev_load(ifr.ifr_name);
2525                         rtnl_lock();
2526                         ret = dev_ethtool(&ifr);
2527                         rtnl_unlock();
2528                         if (!ret) {
2529                                 if (colon)
2530                                         *colon = ':';
2531                                 if (copy_to_user(arg, &ifr,
2532                                                  sizeof(struct ifreq)))
2533                                         ret = -EFAULT;
2534                         }
2535                         return ret;
2536
2537                 /*
2538                  *      These ioctl calls:
2539                  *      - require superuser power.
2540                  *      - require strict serialization.
2541                  *      - return a value
2542                  */
2543                 case SIOCGMIIPHY:
2544                 case SIOCGMIIREG:
2545                 case SIOCSIFNAME:
2546                         if (!capable(CAP_NET_ADMIN))
2547                                 return -EPERM;
2548                         dev_load(ifr.ifr_name);
2549                         rtnl_lock();
2550                         ret = dev_ifsioc(&ifr, cmd);
2551                         rtnl_unlock();
2552                         if (!ret) {
2553                                 if (colon)
2554                                         *colon = ':';
2555                                 if (copy_to_user(arg, &ifr,
2556                                                  sizeof(struct ifreq)))
2557                                         ret = -EFAULT;
2558                         }
2559                         return ret;
2560
2561                 /*
2562                  *      These ioctl calls:
2563                  *      - require superuser power.
2564                  *      - require strict serialization.
2565                  *      - do not return a value
2566                  */
2567                 case SIOCSIFFLAGS:
2568                 case SIOCSIFMETRIC:
2569                 case SIOCSIFMTU:
2570                 case SIOCSIFMAP:
2571                 case SIOCSIFHWADDR:
2572                 case SIOCSIFSLAVE:
2573                 case SIOCADDMULTI:
2574                 case SIOCDELMULTI:
2575                 case SIOCSIFHWBROADCAST:
2576                 case SIOCSIFTXQLEN:
2577                 case SIOCSMIIREG:
2578                 case SIOCBONDENSLAVE:
2579                 case SIOCBONDRELEASE:
2580                 case SIOCBONDSETHWADDR:
2581                 case SIOCBONDCHANGEACTIVE:
2582                 case SIOCBRADDIF:
2583                 case SIOCBRDELIF:
2584                         if (!capable(CAP_NET_ADMIN))
2585                                 return -EPERM;
2586                         /* fall through */
2587                 case SIOCBONDSLAVEINFOQUERY:
2588                 case SIOCBONDINFOQUERY:
2589                         dev_load(ifr.ifr_name);
2590                         rtnl_lock();
2591                         ret = dev_ifsioc(&ifr, cmd);
2592                         rtnl_unlock();
2593                         return ret;
2594
2595                 case SIOCGIFMEM:
2596                         /* Get the per device memory space. We can add this but
2597                          * currently do not support it */
2598                 case SIOCSIFMEM:
2599                         /* Set the per device memory buffer space.
2600                          * Not applicable in our case */
2601                 case SIOCSIFLINK:
2602                         return -EINVAL;
2603
2604                 /*
2605                  *      Unknown or private ioctl.
2606                  */
2607                 default:
2608                         if (cmd == SIOCWANDEV ||
2609                             (cmd >= SIOCDEVPRIVATE &&
2610                              cmd <= SIOCDEVPRIVATE + 15)) {
2611                                 dev_load(ifr.ifr_name);
2612                                 rtnl_lock();
2613                                 ret = dev_ifsioc(&ifr, cmd);
2614                                 rtnl_unlock();
2615                                 if (!ret && copy_to_user(arg, &ifr,
2616                                                          sizeof(struct ifreq)))
2617                                         ret = -EFAULT;
2618                                 return ret;
2619                         }
2620 #ifdef CONFIG_WIRELESS_EXT
2621                         /* Take care of Wireless Extensions */
2622                         if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
2623                                 /* If command is `set a parameter', or
2624                                  * `get the encoding parameters', check if
2625                                  * the user has the right to do it */
2626                                 if (IW_IS_SET(cmd) || cmd == SIOCGIWENCODE) {
2627                                         if (!capable(CAP_NET_ADMIN))
2628                                                 return -EPERM;
2629                                 }
2630                                 dev_load(ifr.ifr_name);
2631                                 rtnl_lock();
2632                                 /* Follow me in net/core/wireless.c */
2633                                 ret = wireless_process_ioctl(&ifr, cmd);
2634                                 rtnl_unlock();
2635                                 if (IW_IS_GET(cmd) &&
2636                                     copy_to_user(arg, &ifr,
2637                                                  sizeof(struct ifreq)))
2638                                         ret = -EFAULT;
2639                                 return ret;
2640                         }
2641 #endif  /* CONFIG_WIRELESS_EXT */
2642                         return -EINVAL;
2643         }
2644 }
2645
2646
2647 /**
2648  *      dev_new_index   -       allocate an ifindex
2649  *
2650  *      Returns a suitable unique value for a new device interface
2651  *      number.  The caller must hold the rtnl semaphore or the
2652  *      dev_base_lock to be sure it remains unique.
2653  */
2654 static int dev_new_index(void)
2655 {
2656         static int ifindex;
2657         for (;;) {
2658                 if (++ifindex <= 0)
2659                         ifindex = 1;
2660                 if (!__dev_get_by_index(ifindex))
2661                         return ifindex;
2662         }
2663 }
2664
2665 static int dev_boot_phase = 1;
2666
2667 /* Delayed registration/unregisteration */
2668 static DEFINE_SPINLOCK(net_todo_list_lock);
2669 static struct list_head net_todo_list = LIST_HEAD_INIT(net_todo_list);
2670
2671 static inline void net_set_todo(struct net_device *dev)
2672 {
2673         spin_lock(&net_todo_list_lock);
2674         list_add_tail(&dev->todo_list, &net_todo_list);
2675         spin_unlock(&net_todo_list_lock);
2676 }
2677
2678 /**
2679  *      register_netdevice      - register a network device
2680  *      @dev: device to register
2681  *
2682  *      Take a completed network device structure and add it to the kernel
2683  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
2684  *      chain. 0 is returned on success. A negative errno code is returned
2685  *      on a failure to set up the device, or if the name is a duplicate.
2686  *
2687  *      Callers must hold the rtnl semaphore. You may want
2688  *      register_netdev() instead of this.
2689  *
2690  *      BUGS:
2691  *      The locking appears insufficient to guarantee two parallel registers
2692  *      will not get the same name.
2693  */
2694
2695 int register_netdevice(struct net_device *dev)
2696 {
2697         struct hlist_head *head;
2698         struct hlist_node *p;
2699         int ret;
2700
2701         BUG_ON(dev_boot_phase);
2702         ASSERT_RTNL();
2703
2704         /* When net_device's are persistent, this will be fatal. */
2705         BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
2706
2707         spin_lock_init(&dev->queue_lock);
2708         spin_lock_init(&dev->xmit_lock);
2709         dev->xmit_lock_owner = -1;
2710 #ifdef CONFIG_NET_CLS_ACT
2711         spin_lock_init(&dev->ingress_lock);
2712 #endif
2713
2714         ret = alloc_divert_blk(dev);
2715         if (ret)
2716                 goto out;
2717
2718         dev->iflink = -1;
2719
2720         /* Init, if this function is available */
2721         if (dev->init) {
2722                 ret = dev->init(dev);
2723                 if (ret) {
2724                         if (ret > 0)
2725                                 ret = -EIO;
2726                         goto out_err;
2727                 }
2728         }
2729  
2730         if (!dev_valid_name(dev->name)) {
2731                 ret = -EINVAL;
2732                 goto out_err;
2733         }
2734
2735         dev->ifindex = dev_new_index();
2736         if (dev->iflink == -1)
2737                 dev->iflink = dev->ifindex;
2738
2739         /* Check for existence of name */
2740         head = dev_name_hash(dev->name);
2741         hlist_for_each(p, head) {
2742                 struct net_device *d
2743                         = hlist_entry(p, struct net_device, name_hlist);
2744                 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
2745                         ret = -EEXIST;
2746                         goto out_err;
2747                 }
2748         }
2749
2750         /* Fix illegal SG+CSUM combinations. */
2751         if ((dev->features & NETIF_F_SG) &&
2752             !(dev->features & (NETIF_F_IP_CSUM |
2753                                NETIF_F_NO_CSUM |
2754                                NETIF_F_HW_CSUM))) {
2755                 printk("%s: Dropping NETIF_F_SG since no checksum feature.\n",
2756                        dev->name);
2757                 dev->features &= ~NETIF_F_SG;
2758         }
2759
2760         /* TSO requires that SG is present as well. */
2761         if ((dev->features & NETIF_F_TSO) &&
2762             !(dev->features & NETIF_F_SG)) {
2763                 printk("%s: Dropping NETIF_F_TSO since no SG feature.\n",
2764                        dev->name);
2765                 dev->features &= ~NETIF_F_TSO;
2766         }
2767         if (dev->features & NETIF_F_UFO) {
2768                 if (!(dev->features & NETIF_F_HW_CSUM)) {
2769                         printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
2770                                         "NETIF_F_HW_CSUM feature.\n",
2771                                                         dev->name);
2772                         dev->features &= ~NETIF_F_UFO;
2773                 }
2774                 if (!(dev->features & NETIF_F_SG)) {
2775                         printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
2776                                         "NETIF_F_SG feature.\n",
2777                                         dev->name);
2778                         dev->features &= ~NETIF_F_UFO;
2779                 }
2780         }
2781
2782         /*
2783          *      nil rebuild_header routine,
2784          *      that should be never called and used as just bug trap.
2785          */
2786
2787         if (!dev->rebuild_header)
2788                 dev->rebuild_header = default_rebuild_header;
2789
2790         /*
2791          *      Default initial state at registry is that the
2792          *      device is present.
2793          */
2794
2795         set_bit(__LINK_STATE_PRESENT, &dev->state);
2796
2797         dev->next = NULL;
2798         dev_init_scheduler(dev);
2799         write_lock_bh(&dev_base_lock);
2800         *dev_tail = dev;
2801         dev_tail = &dev->next;
2802         hlist_add_head(&dev->name_hlist, head);
2803         hlist_add_head(&dev->index_hlist, dev_index_hash(dev->ifindex));
2804         dev_hold(dev);
2805         dev->reg_state = NETREG_REGISTERING;
2806         write_unlock_bh(&dev_base_lock);
2807
2808         /* Notify protocols, that a new device appeared. */
2809         notifier_call_chain(&netdev_chain, NETDEV_REGISTER, dev);
2810
2811         /* Finish registration after unlock */
2812         net_set_todo(dev);
2813         ret = 0;
2814
2815 out:
2816         return ret;
2817 out_err:
2818         free_divert_blk(dev);
2819         goto out;
2820 }
2821
2822 /**
2823  *      register_netdev - register a network device
2824  *      @dev: device to register
2825  *
2826  *      Take a completed network device structure and add it to the kernel
2827  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
2828  *      chain. 0 is returned on success. A negative errno code is returned
2829  *      on a failure to set up the device, or if the name is a duplicate.
2830  *
2831  *      This is a wrapper around register_netdev that takes the rtnl semaphore
2832  *      and expands the device name if you passed a format string to
2833  *      alloc_netdev.
2834  */
2835 int register_netdev(struct net_device *dev)
2836 {
2837         int err;
2838
2839         rtnl_lock();
2840
2841         /*
2842          * If the name is a format string the caller wants us to do a
2843          * name allocation.
2844          */
2845         if (strchr(dev->name, '%')) {
2846                 err = dev_alloc_name(dev, dev->name);
2847                 if (err < 0)
2848                         goto out;
2849         }
2850         
2851         /*
2852          * Back compatibility hook. Kill this one in 2.5
2853          */
2854         if (dev->name[0] == 0 || dev->name[0] == ' ') {
2855                 err = dev_alloc_name(dev, "eth%d");
2856                 if (err < 0)
2857                         goto out;
2858         }
2859
2860         err = register_netdevice(dev);
2861 out:
2862         rtnl_unlock();
2863         return err;
2864 }
2865 EXPORT_SYMBOL(register_netdev);
2866
2867 /*
2868  * netdev_wait_allrefs - wait until all references are gone.
2869  *
2870  * This is called when unregistering network devices.
2871  *
2872  * Any protocol or device that holds a reference should register
2873  * for netdevice notification, and cleanup and put back the
2874  * reference if they receive an UNREGISTER event.
2875  * We can get stuck here if buggy protocols don't correctly
2876  * call dev_put. 
2877  */
2878 static void netdev_wait_allrefs(struct net_device *dev)
2879 {
2880         unsigned long rebroadcast_time, warning_time;
2881
2882         rebroadcast_time = warning_time = jiffies;
2883         while (atomic_read(&dev->refcnt) != 0) {
2884                 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
2885                         rtnl_lock();
2886
2887                         /* Rebroadcast unregister notification */
2888                         notifier_call_chain(&netdev_chain,
2889                                             NETDEV_UNREGISTER, dev);
2890
2891                         if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
2892                                      &dev->state)) {
2893                                 /* We must not have linkwatch events
2894                                  * pending on unregister. If this
2895                                  * happens, we simply run the queue
2896                                  * unscheduled, resulting in a noop
2897                                  * for this device.
2898                                  */
2899                                 linkwatch_run_queue();
2900                         }
2901
2902                         __rtnl_unlock();
2903
2904                         rebroadcast_time = jiffies;
2905                 }
2906
2907                 msleep(250);
2908
2909                 if (time_after(jiffies, warning_time + 10 * HZ)) {
2910                         printk(KERN_EMERG "unregister_netdevice: "
2911                                "waiting for %s to become free. Usage "
2912                                "count = %d\n",
2913                                dev->name, atomic_read(&dev->refcnt));
2914                         warning_time = jiffies;
2915                 }
2916         }
2917 }
2918
2919 /* The sequence is:
2920  *
2921  *      rtnl_lock();
2922  *      ...
2923  *      register_netdevice(x1);
2924  *      register_netdevice(x2);
2925  *      ...
2926  *      unregister_netdevice(y1);
2927  *      unregister_netdevice(y2);
2928  *      ...
2929  *      rtnl_unlock();
2930  *      free_netdev(y1);
2931  *      free_netdev(y2);
2932  *
2933  * We are invoked by rtnl_unlock() after it drops the semaphore.
2934  * This allows us to deal with problems:
2935  * 1) We can create/delete sysfs objects which invoke hotplug
2936  *    without deadlocking with linkwatch via keventd.
2937  * 2) Since we run with the RTNL semaphore not held, we can sleep
2938  *    safely in order to wait for the netdev refcnt to drop to zero.
2939  */
2940 static DEFINE_MUTEX(net_todo_run_mutex);
2941 void netdev_run_todo(void)
2942 {
2943         struct list_head list = LIST_HEAD_INIT(list);
2944         int err;
2945
2946
2947         /* Need to guard against multiple cpu's getting out of order. */
2948         mutex_lock(&net_todo_run_mutex);
2949
2950         /* Not safe to do outside the semaphore.  We must not return
2951          * until all unregister events invoked by the local processor
2952          * have been completed (either by this todo run, or one on
2953          * another cpu).
2954          */
2955         if (list_empty(&net_todo_list))
2956                 goto out;
2957
2958         /* Snapshot list, allow later requests */
2959         spin_lock(&net_todo_list_lock);
2960         list_splice_init(&net_todo_list, &list);
2961         spin_unlock(&net_todo_list_lock);
2962                 
2963         while (!list_empty(&list)) {
2964                 struct net_device *dev
2965                         = list_entry(list.next, struct net_device, todo_list);
2966                 list_del(&dev->todo_list);
2967
2968                 switch(dev->reg_state) {
2969                 case NETREG_REGISTERING:
2970                         err = netdev_register_sysfs(dev);
2971                         if (err)
2972                                 printk(KERN_ERR "%s: failed sysfs registration (%d)\n",
2973                                        dev->name, err);
2974                         dev->reg_state = NETREG_REGISTERED;
2975                         break;
2976
2977                 case NETREG_UNREGISTERING:
2978                         netdev_unregister_sysfs(dev);
2979                         dev->reg_state = NETREG_UNREGISTERED;
2980
2981                         netdev_wait_allrefs(dev);
2982
2983                         /* paranoia */
2984                         BUG_ON(atomic_read(&dev->refcnt));
2985                         BUG_TRAP(!dev->ip_ptr);
2986                         BUG_TRAP(!dev->ip6_ptr);
2987                         BUG_TRAP(!dev->dn_ptr);
2988
2989
2990                         /* It must be the very last action, 
2991                          * after this 'dev' may point to freed up memory.
2992                          */
2993                         if (dev->destructor)
2994                                 dev->destructor(dev);
2995                         break;
2996
2997                 default:
2998                         printk(KERN_ERR "network todo '%s' but state %d\n",
2999                                dev->name, dev->reg_state);
3000                         break;
3001                 }
3002         }
3003
3004 out:
3005         mutex_unlock(&net_todo_run_mutex);
3006 }
3007
3008 /**
3009  *      alloc_netdev - allocate network device
3010  *      @sizeof_priv:   size of private data to allocate space for
3011  *      @name:          device name format string
3012  *      @setup:         callback to initialize device
3013  *
3014  *      Allocates a struct net_device with private data area for driver use
3015  *      and performs basic initialization.
3016  */
3017 struct net_device *alloc_netdev(int sizeof_priv, const char *name,
3018                 void (*setup)(struct net_device *))
3019 {
3020         void *p;
3021         struct net_device *dev;
3022         int alloc_size;
3023
3024         /* ensure 32-byte alignment of both the device and private area */
3025         alloc_size = (sizeof(*dev) + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
3026         alloc_size += sizeof_priv + NETDEV_ALIGN_CONST;
3027
3028         p = kmalloc(alloc_size, GFP_KERNEL);
3029         if (!p) {
3030                 printk(KERN_ERR "alloc_dev: Unable to allocate device.\n");
3031                 return NULL;
3032         }
3033         memset(p, 0, alloc_size);
3034
3035         dev = (struct net_device *)
3036                 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
3037         dev->padded = (char *)dev - (char *)p;
3038
3039         if (sizeof_priv)
3040                 dev->priv = netdev_priv(dev);
3041
3042         setup(dev);
3043         strcpy(dev->name, name);
3044         return dev;
3045 }
3046 EXPORT_SYMBOL(alloc_netdev);
3047
3048 /**
3049  *      free_netdev - free network device
3050  *      @dev: device
3051  *
3052  *      This function does the last stage of destroying an allocated device 
3053  *      interface. The reference to the device object is released.  
3054  *      If this is the last reference then it will be freed.
3055  */
3056 void free_netdev(struct net_device *dev)
3057 {
3058 #ifdef CONFIG_SYSFS
3059         /*  Compatiablity with error handling in drivers */
3060         if (dev->reg_state == NETREG_UNINITIALIZED) {
3061                 kfree((char *)dev - dev->padded);
3062                 return;
3063         }
3064
3065         BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
3066         dev->reg_state = NETREG_RELEASED;
3067
3068         /* will free via class release */
3069         class_device_put(&dev->class_dev);
3070 #else
3071         kfree((char *)dev - dev->padded);
3072 #endif
3073 }
3074  
3075 /* Synchronize with packet receive processing. */
3076 void synchronize_net(void) 
3077 {
3078         might_sleep();
3079         synchronize_rcu();
3080 }
3081
3082 /**
3083  *      unregister_netdevice - remove device from the kernel
3084  *      @dev: device
3085  *
3086  *      This function shuts down a device interface and removes it
3087  *      from the kernel tables. On success 0 is returned, on a failure
3088  *      a negative errno code is returned.
3089  *
3090  *      Callers must hold the rtnl semaphore.  You may want
3091  *      unregister_netdev() instead of this.
3092  */
3093
3094 int unregister_netdevice(struct net_device *dev)
3095 {
3096         struct net_device *d, **dp;
3097
3098         BUG_ON(dev_boot_phase);
3099         ASSERT_RTNL();
3100
3101         /* Some devices call without registering for initialization unwind. */
3102         if (dev->reg_state == NETREG_UNINITIALIZED) {
3103                 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3104                                   "was registered\n", dev->name, dev);
3105                 return -ENODEV;
3106         }
3107
3108         BUG_ON(dev->reg_state != NETREG_REGISTERED);
3109
3110         /* If device is running, close it first. */
3111         if (dev->flags & IFF_UP)
3112                 dev_close(dev);
3113
3114         /* And unlink it from device chain. */
3115         for (dp = &dev_base; (d = *dp) != NULL; dp = &d->next) {
3116                 if (d == dev) {
3117                         write_lock_bh(&dev_base_lock);
3118                         hlist_del(&dev->name_hlist);
3119                         hlist_del(&dev->index_hlist);
3120                         if (dev_tail == &dev->next)
3121                                 dev_tail = dp;
3122                         *dp = d->next;
3123                         write_unlock_bh(&dev_base_lock);
3124                         break;
3125                 }
3126         }
3127         if (!d) {
3128                 printk(KERN_ERR "unregister net_device: '%s' not found\n",
3129                        dev->name);
3130                 return -ENODEV;
3131         }
3132
3133         dev->reg_state = NETREG_UNREGISTERING;
3134
3135         synchronize_net();
3136
3137         /* Shutdown queueing discipline. */
3138         dev_shutdown(dev);
3139
3140         
3141         /* Notify protocols, that we are about to destroy
3142            this device. They should clean all the things.
3143         */
3144         notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev);
3145         
3146         /*
3147          *      Flush the multicast chain
3148          */
3149         dev_mc_discard(dev);
3150
3151         if (dev->uninit)
3152                 dev->uninit(dev);
3153
3154         /* Notifier chain MUST detach us from master device. */
3155         BUG_TRAP(!dev->master);
3156
3157         free_divert_blk(dev);
3158
3159         /* Finish processing unregister after unlock */
3160         net_set_todo(dev);
3161
3162         synchronize_net();
3163
3164         dev_put(dev);
3165         return 0;
3166 }
3167
3168 /**
3169  *      unregister_netdev - remove device from the kernel
3170  *      @dev: device
3171  *
3172  *      This function shuts down a device interface and removes it
3173  *      from the kernel tables. On success 0 is returned, on a failure
3174  *      a negative errno code is returned.
3175  *
3176  *      This is just a wrapper for unregister_netdevice that takes
3177  *      the rtnl semaphore.  In general you want to use this and not
3178  *      unregister_netdevice.
3179  */
3180 void unregister_netdev(struct net_device *dev)
3181 {
3182         rtnl_lock();
3183         unregister_netdevice(dev);
3184         rtnl_unlock();
3185 }
3186
3187 EXPORT_SYMBOL(unregister_netdev);
3188
3189 #ifdef CONFIG_HOTPLUG_CPU
3190 static int dev_cpu_callback(struct notifier_block *nfb,
3191                             unsigned long action,
3192                             void *ocpu)
3193 {
3194         struct sk_buff **list_skb;
3195         struct net_device **list_net;
3196         struct sk_buff *skb;
3197         unsigned int cpu, oldcpu = (unsigned long)ocpu;
3198         struct softnet_data *sd, *oldsd;
3199
3200         if (action != CPU_DEAD)
3201                 return NOTIFY_OK;
3202
3203         local_irq_disable();
3204         cpu = smp_processor_id();
3205         sd = &per_cpu(softnet_data, cpu);
3206         oldsd = &per_cpu(softnet_data, oldcpu);
3207
3208         /* Find end of our completion_queue. */
3209         list_skb = &sd->completion_queue;
3210         while (*list_skb)
3211                 list_skb = &(*list_skb)->next;
3212         /* Append completion queue from offline CPU. */
3213         *list_skb = oldsd->completion_queue;
3214         oldsd->completion_queue = NULL;
3215
3216         /* Find end of our output_queue. */
3217         list_net = &sd->output_queue;
3218         while (*list_net)
3219                 list_net = &(*list_net)->next_sched;
3220         /* Append output queue from offline CPU. */
3221         *list_net = oldsd->output_queue;
3222         oldsd->output_queue = NULL;
3223
3224         raise_softirq_irqoff(NET_TX_SOFTIRQ);
3225         local_irq_enable();
3226
3227         /* Process offline CPU's input_pkt_queue */
3228         while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
3229                 netif_rx(skb);
3230
3231         return NOTIFY_OK;
3232 }
3233 #endif /* CONFIG_HOTPLUG_CPU */
3234
3235
3236 /*
3237  *      Initialize the DEV module. At boot time this walks the device list and
3238  *      unhooks any devices that fail to initialise (normally hardware not
3239  *      present) and leaves us with a valid list of present and active devices.
3240  *
3241  */
3242
3243 /*
3244  *       This is called single threaded during boot, so no need
3245  *       to take the rtnl semaphore.
3246  */
3247 static int __init net_dev_init(void)
3248 {
3249         int i, rc = -ENOMEM;
3250
3251         BUG_ON(!dev_boot_phase);
3252
3253         net_random_init();
3254
3255         if (dev_proc_init())
3256                 goto out;
3257
3258         if (netdev_sysfs_init())
3259                 goto out;
3260
3261         INIT_LIST_HEAD(&ptype_all);
3262         for (i = 0; i < 16; i++) 
3263                 INIT_LIST_HEAD(&ptype_base[i]);
3264
3265         for (i = 0; i < ARRAY_SIZE(dev_name_head); i++)
3266                 INIT_HLIST_HEAD(&dev_name_head[i]);
3267
3268         for (i = 0; i < ARRAY_SIZE(dev_index_head); i++)
3269                 INIT_HLIST_HEAD(&dev_index_head[i]);
3270
3271         /*
3272          *      Initialise the packet receive queues.
3273          */
3274
3275         for_each_cpu(i) {
3276                 struct softnet_data *queue;
3277
3278                 queue = &per_cpu(softnet_data, i);
3279                 skb_queue_head_init(&queue->input_pkt_queue);
3280                 queue->completion_queue = NULL;
3281                 INIT_LIST_HEAD(&queue->poll_list);
3282                 set_bit(__LINK_STATE_START, &queue->backlog_dev.state);
3283                 queue->backlog_dev.weight = weight_p;
3284                 queue->backlog_dev.poll = process_backlog;
3285                 atomic_set(&queue->backlog_dev.refcnt, 1);
3286         }
3287
3288         dev_boot_phase = 0;
3289
3290         open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
3291         open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
3292
3293         hotcpu_notifier(dev_cpu_callback, 0);
3294         dst_init();
3295         dev_mcast_init();
3296         rc = 0;
3297 out:
3298         return rc;
3299 }
3300
3301 subsys_initcall(net_dev_init);
3302
3303 EXPORT_SYMBOL(__dev_get_by_index);
3304 EXPORT_SYMBOL(__dev_get_by_name);
3305 EXPORT_SYMBOL(__dev_remove_pack);
3306 EXPORT_SYMBOL(__skb_linearize);
3307 EXPORT_SYMBOL(dev_valid_name);
3308 EXPORT_SYMBOL(dev_add_pack);
3309 EXPORT_SYMBOL(dev_alloc_name);
3310 EXPORT_SYMBOL(dev_close);
3311 EXPORT_SYMBOL(dev_get_by_flags);
3312 EXPORT_SYMBOL(dev_get_by_index);
3313 EXPORT_SYMBOL(dev_get_by_name);
3314 EXPORT_SYMBOL(dev_open);
3315 EXPORT_SYMBOL(dev_queue_xmit);
3316 EXPORT_SYMBOL(dev_remove_pack);
3317 EXPORT_SYMBOL(dev_set_allmulti);
3318 EXPORT_SYMBOL(dev_set_promiscuity);
3319 EXPORT_SYMBOL(dev_change_flags);
3320 EXPORT_SYMBOL(dev_set_mtu);
3321 EXPORT_SYMBOL(dev_set_mac_address);
3322 EXPORT_SYMBOL(free_netdev);
3323 EXPORT_SYMBOL(netdev_boot_setup_check);
3324 EXPORT_SYMBOL(netdev_set_master);
3325 EXPORT_SYMBOL(netdev_state_change);
3326 EXPORT_SYMBOL(netif_receive_skb);
3327 EXPORT_SYMBOL(netif_rx);
3328 EXPORT_SYMBOL(register_gifconf);
3329 EXPORT_SYMBOL(register_netdevice);
3330 EXPORT_SYMBOL(register_netdevice_notifier);
3331 EXPORT_SYMBOL(skb_checksum_help);
3332 EXPORT_SYMBOL(synchronize_net);
3333 EXPORT_SYMBOL(unregister_netdevice);
3334 EXPORT_SYMBOL(unregister_netdevice_notifier);
3335 EXPORT_SYMBOL(net_enable_timestamp);
3336 EXPORT_SYMBOL(net_disable_timestamp);
3337 EXPORT_SYMBOL(dev_get_flags);
3338
3339 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
3340 EXPORT_SYMBOL(br_handle_frame_hook);
3341 EXPORT_SYMBOL(br_fdb_get_hook);
3342 EXPORT_SYMBOL(br_fdb_put_hook);
3343 #endif
3344
3345 #ifdef CONFIG_KMOD
3346 EXPORT_SYMBOL(dev_load);