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