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