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