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