blob: eb999003bbb7646634acac8c69eeb0c5663cca8d [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/cpu.h>
80#include <linux/types.h>
81#include <linux/kernel.h>
82#include <linux/sched.h>
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -080083#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070084#include <linux/string.h>
85#include <linux/mm.h>
86#include <linux/socket.h>
87#include <linux/sockios.h>
88#include <linux/errno.h>
89#include <linux/interrupt.h>
90#include <linux/if_ether.h>
91#include <linux/netdevice.h>
92#include <linux/etherdevice.h>
93#include <linux/notifier.h>
94#include <linux/skbuff.h>
95#include <net/sock.h>
96#include <linux/rtnetlink.h>
97#include <linux/proc_fs.h>
98#include <linux/seq_file.h>
99#include <linux/stat.h>
100#include <linux/if_bridge.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101#include <net/dst.h>
102#include <net/pkt_sched.h>
103#include <net/checksum.h>
104#include <linux/highmem.h>
105#include <linux/init.h>
106#include <linux/kmod.h>
107#include <linux/module.h>
108#include <linux/kallsyms.h>
109#include <linux/netpoll.h>
110#include <linux/rcupdate.h>
111#include <linux/delay.h>
Johannes Berg295f4a12007-04-26 20:43:56 -0700112#include <net/wext.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113#include <net/iw_handler.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114#include <asm/current.h>
Steve Grubb5bdb9882005-12-03 08:39:35 -0500115#include <linux/audit.h>
Chris Leechdb217332006-06-17 21:24:58 -0700116#include <linux/dmaengine.h>
Herbert Xuf6a78bf2006-06-22 02:57:17 -0700117#include <linux/err.h>
David S. Millerc7fa9d12006-08-15 16:34:13 -0700118#include <linux/ctype.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);
Stephen Hemminger6b2bedc2007-03-12 14:33:50 -0700149static struct list_head ptype_base[16] __read_mostly; /* 16 way hashed list */
150static struct list_head ptype_all __read_mostly; /* Taps */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
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/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 * Add a protocol ID to the list. Now that the input handler is
230 * smarter we can dispense with all the messy stuff that used to be
231 * here.
232 *
233 * BEWARE!!! Protocol handlers, mangling input packets,
234 * MUST BE last in hash buckets and checking protocol handlers
235 * MUST start from promiscuous ptype_all chain in net_bh.
236 * It is true now, do not change it.
237 * Explanation follows: if protocol handler, mangling packet, will
238 * be the first on list, it is not able to sense, that packet
239 * is cloned and should be copied-on-write, so that it will
240 * change it and subsequent readers will get broken packet.
241 * --ANK (980803)
242 */
243
244/**
245 * dev_add_pack - add packet handler
246 * @pt: packet type declaration
247 *
248 * Add a protocol handler to the networking stack. The passed &packet_type
249 * is linked into kernel lists and may not be freed until it has been
250 * removed from the kernel lists.
251 *
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900252 * This call does not sleep therefore it can not
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 * guarantee all CPU's that are in middle of receiving packets
254 * will see the new packet type (until the next received packet).
255 */
256
257void dev_add_pack(struct packet_type *pt)
258{
259 int hash;
260
261 spin_lock_bh(&ptype_lock);
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -0700262 if (pt->type == htons(ETH_P_ALL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 list_add_rcu(&pt->list, &ptype_all);
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -0700264 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 hash = ntohs(pt->type) & 15;
266 list_add_rcu(&pt->list, &ptype_base[hash]);
267 }
268 spin_unlock_bh(&ptype_lock);
269}
270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271/**
272 * __dev_remove_pack - remove packet handler
273 * @pt: packet type declaration
274 *
275 * Remove a protocol handler that was previously added to the kernel
276 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
277 * from the kernel lists and can be freed or reused once this function
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900278 * returns.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 *
280 * The packet type might still be in use by receivers
281 * and must not be freed until after all the CPU's have gone
282 * through a quiescent state.
283 */
284void __dev_remove_pack(struct packet_type *pt)
285{
286 struct list_head *head;
287 struct packet_type *pt1;
288
289 spin_lock_bh(&ptype_lock);
290
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -0700291 if (pt->type == htons(ETH_P_ALL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 head = &ptype_all;
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -0700293 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 head = &ptype_base[ntohs(pt->type) & 15];
295
296 list_for_each_entry(pt1, head, list) {
297 if (pt == pt1) {
298 list_del_rcu(&pt->list);
299 goto out;
300 }
301 }
302
303 printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
304out:
305 spin_unlock_bh(&ptype_lock);
306}
307/**
308 * dev_remove_pack - remove packet handler
309 * @pt: packet type declaration
310 *
311 * Remove a protocol handler that was previously added to the kernel
312 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
313 * from the kernel lists and can be freed or reused once this function
314 * returns.
315 *
316 * This call sleeps to guarantee that no CPU is looking at the packet
317 * type after return.
318 */
319void dev_remove_pack(struct packet_type *pt)
320{
321 __dev_remove_pack(pt);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 synchronize_net();
324}
325
326/******************************************************************************
327
328 Device Boot-time Settings Routines
329
330*******************************************************************************/
331
332/* Boot time configuration table */
333static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
334
335/**
336 * netdev_boot_setup_add - add new setup entry
337 * @name: name of the device
338 * @map: configured settings for the device
339 *
340 * Adds new setup entry to the dev_boot_setup list. The function
341 * returns 0 on error and 1 on success. This is a generic routine to
342 * all netdevices.
343 */
344static int netdev_boot_setup_add(char *name, struct ifmap *map)
345{
346 struct netdev_boot_setup *s;
347 int i;
348
349 s = dev_boot_setup;
350 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
351 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
352 memset(s[i].name, 0, sizeof(s[i].name));
353 strcpy(s[i].name, name);
354 memcpy(&s[i].map, map, sizeof(s[i].map));
355 break;
356 }
357 }
358
359 return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
360}
361
362/**
363 * netdev_boot_setup_check - check boot time settings
364 * @dev: the netdevice
365 *
366 * Check boot time settings for the device.
367 * The found settings are set for the device to be used
368 * later in the device probing.
369 * Returns 0 if no settings found, 1 if they are.
370 */
371int netdev_boot_setup_check(struct net_device *dev)
372{
373 struct netdev_boot_setup *s = dev_boot_setup;
374 int i;
375
376 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
377 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
378 !strncmp(dev->name, s[i].name, strlen(s[i].name))) {
379 dev->irq = s[i].map.irq;
380 dev->base_addr = s[i].map.base_addr;
381 dev->mem_start = s[i].map.mem_start;
382 dev->mem_end = s[i].map.mem_end;
383 return 1;
384 }
385 }
386 return 0;
387}
388
389
390/**
391 * netdev_boot_base - get address from boot time settings
392 * @prefix: prefix for network device
393 * @unit: id for network device
394 *
395 * Check boot time settings for the base address of device.
396 * The found settings are set for the device to be used
397 * later in the device probing.
398 * Returns 0 if no settings found.
399 */
400unsigned long netdev_boot_base(const char *prefix, int unit)
401{
402 const struct netdev_boot_setup *s = dev_boot_setup;
403 char name[IFNAMSIZ];
404 int i;
405
406 sprintf(name, "%s%d", prefix, unit);
407
408 /*
409 * If device already registered then return base of 1
410 * to indicate not to probe for this interface
411 */
412 if (__dev_get_by_name(name))
413 return 1;
414
415 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
416 if (!strcmp(name, s[i].name))
417 return s[i].map.base_addr;
418 return 0;
419}
420
421/*
422 * Saves at boot time configured settings for any netdevice.
423 */
424int __init netdev_boot_setup(char *str)
425{
426 int ints[5];
427 struct ifmap map;
428
429 str = get_options(str, ARRAY_SIZE(ints), ints);
430 if (!str || !*str)
431 return 0;
432
433 /* Save settings */
434 memset(&map, 0, sizeof(map));
435 if (ints[0] > 0)
436 map.irq = ints[1];
437 if (ints[0] > 1)
438 map.base_addr = ints[2];
439 if (ints[0] > 2)
440 map.mem_start = ints[3];
441 if (ints[0] > 3)
442 map.mem_end = ints[4];
443
444 /* Add new entry to the list */
445 return netdev_boot_setup_add(str, &map);
446}
447
448__setup("netdev=", netdev_boot_setup);
449
450/*******************************************************************************
451
452 Device Interface Subroutines
453
454*******************************************************************************/
455
456/**
457 * __dev_get_by_name - find a device by its name
458 * @name: name to find
459 *
460 * Find an interface by name. Must be called under RTNL semaphore
461 * or @dev_base_lock. If the name is found a pointer to the device
462 * is returned. If the name is not found then %NULL is returned. The
463 * reference counters are not incremented so the caller must be
464 * careful with locks.
465 */
466
467struct net_device *__dev_get_by_name(const char *name)
468{
469 struct hlist_node *p;
470
471 hlist_for_each(p, dev_name_hash(name)) {
472 struct net_device *dev
473 = hlist_entry(p, struct net_device, name_hlist);
474 if (!strncmp(dev->name, name, IFNAMSIZ))
475 return dev;
476 }
477 return NULL;
478}
479
480/**
481 * dev_get_by_name - find a device by its name
482 * @name: name to find
483 *
484 * Find an interface by name. This can be called from any
485 * context and does its own locking. The returned handle has
486 * the usage count incremented and the caller must use dev_put() to
487 * release it when it is no longer needed. %NULL is returned if no
488 * matching device is found.
489 */
490
491struct net_device *dev_get_by_name(const char *name)
492{
493 struct net_device *dev;
494
495 read_lock(&dev_base_lock);
496 dev = __dev_get_by_name(name);
497 if (dev)
498 dev_hold(dev);
499 read_unlock(&dev_base_lock);
500 return dev;
501}
502
503/**
504 * __dev_get_by_index - find a device by its ifindex
505 * @ifindex: index of device
506 *
507 * Search for an interface by index. Returns %NULL if the device
508 * is not found or a pointer to the device. The device has not
509 * had its reference counter increased so the caller must be careful
510 * about locking. The caller must hold either the RTNL semaphore
511 * or @dev_base_lock.
512 */
513
514struct net_device *__dev_get_by_index(int ifindex)
515{
516 struct hlist_node *p;
517
518 hlist_for_each(p, dev_index_hash(ifindex)) {
519 struct net_device *dev
520 = hlist_entry(p, struct net_device, index_hlist);
521 if (dev->ifindex == ifindex)
522 return dev;
523 }
524 return NULL;
525}
526
527
528/**
529 * dev_get_by_index - find a device by its ifindex
530 * @ifindex: index of device
531 *
532 * Search for an interface by index. Returns NULL if the device
533 * is not found or a pointer to the device. The device returned has
534 * had a reference added and the pointer is safe until the user calls
535 * dev_put to indicate they have finished with it.
536 */
537
538struct net_device *dev_get_by_index(int ifindex)
539{
540 struct net_device *dev;
541
542 read_lock(&dev_base_lock);
543 dev = __dev_get_by_index(ifindex);
544 if (dev)
545 dev_hold(dev);
546 read_unlock(&dev_base_lock);
547 return dev;
548}
549
550/**
551 * dev_getbyhwaddr - find a device by its hardware address
552 * @type: media type of device
553 * @ha: hardware address
554 *
555 * Search for an interface by MAC address. Returns NULL if the device
556 * is not found or a pointer to the device. The caller must hold the
557 * rtnl semaphore. The returned device has not had its ref count increased
558 * and the caller must therefore be careful about locking
559 *
560 * BUGS:
561 * If the API was consistent this would be __dev_get_by_hwaddr
562 */
563
564struct net_device *dev_getbyhwaddr(unsigned short type, char *ha)
565{
566 struct net_device *dev;
567
568 ASSERT_RTNL();
569
570 for (dev = dev_base; dev; dev = dev->next)
571 if (dev->type == type &&
572 !memcmp(dev->dev_addr, ha, dev->addr_len))
573 break;
574 return dev;
575}
576
Jochen Friedrichcf309e32005-09-22 04:44:55 -0300577EXPORT_SYMBOL(dev_getbyhwaddr);
578
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579struct net_device *dev_getfirstbyhwtype(unsigned short type)
580{
581 struct net_device *dev;
582
583 rtnl_lock();
584 for (dev = dev_base; dev; dev = dev->next) {
585 if (dev->type == type) {
586 dev_hold(dev);
587 break;
588 }
589 }
590 rtnl_unlock();
591 return dev;
592}
593
594EXPORT_SYMBOL(dev_getfirstbyhwtype);
595
596/**
597 * dev_get_by_flags - find any device with given flags
598 * @if_flags: IFF_* values
599 * @mask: bitmask of bits in if_flags to check
600 *
601 * Search for any interface with the given flags. Returns NULL if a device
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900602 * is not found or a pointer to the device. The device returned has
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 * had a reference added and the pointer is safe until the user calls
604 * dev_put to indicate they have finished with it.
605 */
606
607struct net_device * dev_get_by_flags(unsigned short if_flags, unsigned short mask)
608{
609 struct net_device *dev;
610
611 read_lock(&dev_base_lock);
612 for (dev = dev_base; dev != NULL; dev = dev->next) {
613 if (((dev->flags ^ if_flags) & mask) == 0) {
614 dev_hold(dev);
615 break;
616 }
617 }
618 read_unlock(&dev_base_lock);
619 return dev;
620}
621
622/**
623 * dev_valid_name - check if name is okay for network device
624 * @name: name string
625 *
626 * Network device names need to be valid file names to
David S. Millerc7fa9d12006-08-15 16:34:13 -0700627 * to allow sysfs to work. We also disallow any kind of
628 * whitespace.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 */
Mitch Williamsc2373ee2005-11-09 10:34:45 -0800630int dev_valid_name(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
David S. Millerc7fa9d12006-08-15 16:34:13 -0700632 if (*name == '\0')
633 return 0;
Stephen Hemmingerb6fe17d2006-08-29 17:06:13 -0700634 if (strlen(name) >= IFNAMSIZ)
635 return 0;
David S. Millerc7fa9d12006-08-15 16:34:13 -0700636 if (!strcmp(name, ".") || !strcmp(name, ".."))
637 return 0;
638
639 while (*name) {
640 if (*name == '/' || isspace(*name))
641 return 0;
642 name++;
643 }
644 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645}
646
647/**
648 * dev_alloc_name - allocate a name for a device
649 * @dev: device
650 * @name: name format string
651 *
652 * Passed a format string - eg "lt%d" it will try and find a suitable
Stephen Hemminger3041a062006-05-26 13:25:24 -0700653 * id. It scans list of devices to build up a free map, then chooses
654 * the first empty slot. The caller must hold the dev_base or rtnl lock
655 * while allocating the name and adding the device in order to avoid
656 * duplicates.
657 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
658 * Returns the number of the unit assigned or a negative errno code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 */
660
661int dev_alloc_name(struct net_device *dev, const char *name)
662{
663 int i = 0;
664 char buf[IFNAMSIZ];
665 const char *p;
666 const int max_netdevices = 8*PAGE_SIZE;
667 long *inuse;
668 struct net_device *d;
669
670 p = strnchr(name, IFNAMSIZ-1, '%');
671 if (p) {
672 /*
673 * Verify the string as this thing may have come from
674 * the user. There must be either one "%d" and no other "%"
675 * characters.
676 */
677 if (p[1] != 'd' || strchr(p + 2, '%'))
678 return -EINVAL;
679
680 /* Use one page as a bit array of possible slots */
681 inuse = (long *) get_zeroed_page(GFP_ATOMIC);
682 if (!inuse)
683 return -ENOMEM;
684
685 for (d = dev_base; d; d = d->next) {
686 if (!sscanf(d->name, name, &i))
687 continue;
688 if (i < 0 || i >= max_netdevices)
689 continue;
690
691 /* avoid cases where sscanf is not exact inverse of printf */
692 snprintf(buf, sizeof(buf), name, i);
693 if (!strncmp(buf, d->name, IFNAMSIZ))
694 set_bit(i, inuse);
695 }
696
697 i = find_first_zero_bit(inuse, max_netdevices);
698 free_page((unsigned long) inuse);
699 }
700
701 snprintf(buf, sizeof(buf), name, i);
702 if (!__dev_get_by_name(buf)) {
703 strlcpy(dev->name, buf, IFNAMSIZ);
704 return i;
705 }
706
707 /* It is possible to run out of possible slots
708 * when the name is long and there isn't enough space left
709 * for the digits, or if all bits are used.
710 */
711 return -ENFILE;
712}
713
714
715/**
716 * dev_change_name - change name of a device
717 * @dev: device
718 * @newname: name (or format string) must be at least IFNAMSIZ
719 *
720 * Change name of a device, can pass format strings "eth%d".
721 * for wildcarding.
722 */
723int dev_change_name(struct net_device *dev, char *newname)
724{
725 int err = 0;
726
727 ASSERT_RTNL();
728
729 if (dev->flags & IFF_UP)
730 return -EBUSY;
731
732 if (!dev_valid_name(newname))
733 return -EINVAL;
734
735 if (strchr(newname, '%')) {
736 err = dev_alloc_name(dev, newname);
737 if (err < 0)
738 return err;
739 strcpy(newname, dev->name);
740 }
741 else if (__dev_get_by_name(newname))
742 return -EEXIST;
743 else
744 strlcpy(dev->name, newname, IFNAMSIZ);
745
Eric W. Biederman92749822007-04-03 00:07:30 -0600746 device_rename(&dev->dev, dev->name);
747 hlist_del(&dev->name_hlist);
748 hlist_add_head(&dev->name_hlist, dev_name_hash(dev->name));
749 raw_notifier_call_chain(&netdev_chain, NETDEV_CHANGENAME, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
751 return err;
752}
753
754/**
Stephen Hemminger3041a062006-05-26 13:25:24 -0700755 * netdev_features_change - device changes features
Stephen Hemmingerd8a33ac2005-05-29 14:13:47 -0700756 * @dev: device to cause notification
757 *
758 * Called to indicate a device has changed features.
759 */
760void netdev_features_change(struct net_device *dev)
761{
Alan Sternf07d5b92006-05-09 15:23:03 -0700762 raw_notifier_call_chain(&netdev_chain, NETDEV_FEAT_CHANGE, dev);
Stephen Hemmingerd8a33ac2005-05-29 14:13:47 -0700763}
764EXPORT_SYMBOL(netdev_features_change);
765
766/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 * netdev_state_change - device changes state
768 * @dev: device to cause notification
769 *
770 * Called to indicate a device has changed state. This function calls
771 * the notifier chains for netdev_chain and sends a NEWLINK message
772 * to the routing socket.
773 */
774void netdev_state_change(struct net_device *dev)
775{
776 if (dev->flags & IFF_UP) {
Alan Sternf07d5b92006-05-09 15:23:03 -0700777 raw_notifier_call_chain(&netdev_chain,
Alan Sterne041c682006-03-27 01:16:30 -0800778 NETDEV_CHANGE, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
780 }
781}
782
783/**
784 * dev_load - load a network module
785 * @name: name of interface
786 *
787 * If a network interface is not present and the process has suitable
788 * privileges this function loads the module. If module loading is not
789 * available in this kernel then it becomes a nop.
790 */
791
792void dev_load(const char *name)
793{
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900794 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
796 read_lock(&dev_base_lock);
797 dev = __dev_get_by_name(name);
798 read_unlock(&dev_base_lock);
799
800 if (!dev && capable(CAP_SYS_MODULE))
801 request_module("%s", name);
802}
803
804static int default_rebuild_header(struct sk_buff *skb)
805{
806 printk(KERN_DEBUG "%s: default_rebuild_header called -- BUG!\n",
807 skb->dev ? skb->dev->name : "NULL!!!");
808 kfree_skb(skb);
809 return 1;
810}
811
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812/**
813 * dev_open - prepare an interface for use.
814 * @dev: device to open
815 *
816 * Takes a device from down to up state. The device's private open
817 * function is invoked and then the multicast lists are loaded. Finally
818 * the device is moved into the up state and a %NETDEV_UP message is
819 * sent to the netdev notifier chain.
820 *
821 * Calling this function on an active interface is a nop. On a failure
822 * a negative errno code is returned.
823 */
824int dev_open(struct net_device *dev)
825{
826 int ret = 0;
827
828 /*
829 * Is it already up?
830 */
831
832 if (dev->flags & IFF_UP)
833 return 0;
834
835 /*
836 * Is it even present?
837 */
838 if (!netif_device_present(dev))
839 return -ENODEV;
840
841 /*
842 * Call device private open method
843 */
844 set_bit(__LINK_STATE_START, &dev->state);
845 if (dev->open) {
846 ret = dev->open(dev);
847 if (ret)
848 clear_bit(__LINK_STATE_START, &dev->state);
849 }
850
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900851 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 * If it went open OK then:
853 */
854
855 if (!ret) {
856 /*
857 * Set the flags.
858 */
859 dev->flags |= IFF_UP;
860
861 /*
862 * Initialize multicasting status
863 */
864 dev_mc_upload(dev);
865
866 /*
867 * Wakeup transmit queue engine
868 */
869 dev_activate(dev);
870
871 /*
872 * ... and announce new interface.
873 */
Alan Sternf07d5b92006-05-09 15:23:03 -0700874 raw_notifier_call_chain(&netdev_chain, NETDEV_UP, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 }
876 return ret;
877}
878
879/**
880 * dev_close - shutdown an interface.
881 * @dev: device to shutdown
882 *
883 * This function moves an active device into down state. A
884 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
885 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
886 * chain.
887 */
888int dev_close(struct net_device *dev)
889{
890 if (!(dev->flags & IFF_UP))
891 return 0;
892
893 /*
894 * Tell people we are going down, so that they can
895 * prepare to death, when device is still operating.
896 */
Alan Sternf07d5b92006-05-09 15:23:03 -0700897 raw_notifier_call_chain(&netdev_chain, NETDEV_GOING_DOWN, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898
899 dev_deactivate(dev);
900
901 clear_bit(__LINK_STATE_START, &dev->state);
902
903 /* Synchronize to scheduled poll. We cannot touch poll list,
904 * it can be even on different cpu. So just clear netif_running(),
905 * and wait when poll really will happen. Actually, the best place
906 * for this is inside dev->stop() after device stopped its irq
907 * engine, but this requires more changes in devices. */
908
909 smp_mb__after_clear_bit(); /* Commit netif_running(). */
910 while (test_bit(__LINK_STATE_RX_SCHED, &dev->state)) {
911 /* No hurry. */
David S. Miller6192b542005-07-28 12:12:58 -0700912 msleep(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 }
914
915 /*
916 * Call the device specific close. This cannot fail.
917 * Only if device is UP
918 *
919 * We allow it to be called even after a DETACH hot-plug
920 * event.
921 */
922 if (dev->stop)
923 dev->stop(dev);
924
925 /*
926 * Device is now down.
927 */
928
929 dev->flags &= ~IFF_UP;
930
931 /*
932 * Tell people we are down
933 */
Alan Sternf07d5b92006-05-09 15:23:03 -0700934 raw_notifier_call_chain(&netdev_chain, NETDEV_DOWN, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
936 return 0;
937}
938
939
940/*
941 * Device change register/unregister. These are not inline or static
942 * as we export them to the world.
943 */
944
945/**
946 * register_netdevice_notifier - register a network notifier block
947 * @nb: notifier
948 *
949 * Register a notifier to be called when network device events occur.
950 * The notifier passed is linked into the kernel structures and must
951 * not be reused until it has been unregistered. A negative errno code
952 * is returned on a failure.
953 *
954 * When registered all registration and up events are replayed
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900955 * to the new notifier to allow device to have a race free
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 * view of the network device list.
957 */
958
959int register_netdevice_notifier(struct notifier_block *nb)
960{
961 struct net_device *dev;
962 int err;
963
964 rtnl_lock();
Alan Sternf07d5b92006-05-09 15:23:03 -0700965 err = raw_notifier_chain_register(&netdev_chain, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 if (!err) {
967 for (dev = dev_base; dev; dev = dev->next) {
968 nb->notifier_call(nb, NETDEV_REGISTER, dev);
969
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900970 if (dev->flags & IFF_UP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 nb->notifier_call(nb, NETDEV_UP, dev);
972 }
973 }
974 rtnl_unlock();
975 return err;
976}
977
978/**
979 * unregister_netdevice_notifier - unregister a network notifier block
980 * @nb: notifier
981 *
982 * Unregister a notifier previously registered by
983 * register_netdevice_notifier(). The notifier is unlinked into the
984 * kernel structures and may then be reused. A negative errno code
985 * is returned on a failure.
986 */
987
988int unregister_netdevice_notifier(struct notifier_block *nb)
989{
Herbert Xu9f514952006-03-25 01:24:25 -0800990 int err;
991
992 rtnl_lock();
Alan Sternf07d5b92006-05-09 15:23:03 -0700993 err = raw_notifier_chain_unregister(&netdev_chain, nb);
Herbert Xu9f514952006-03-25 01:24:25 -0800994 rtnl_unlock();
995 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996}
997
998/**
999 * call_netdevice_notifiers - call all network notifier blocks
1000 * @val: value passed unmodified to notifier function
1001 * @v: pointer passed unmodified to notifier function
1002 *
1003 * Call all network notifier blocks. Parameters and return value
Alan Sternf07d5b92006-05-09 15:23:03 -07001004 * are as for raw_notifier_call_chain().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 */
1006
1007int call_netdevice_notifiers(unsigned long val, void *v)
1008{
Alan Sternf07d5b92006-05-09 15:23:03 -07001009 return raw_notifier_call_chain(&netdev_chain, val, v);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010}
1011
1012/* When > 0 there are consumers of rx skb time stamps */
1013static atomic_t netstamp_needed = ATOMIC_INIT(0);
1014
1015void net_enable_timestamp(void)
1016{
1017 atomic_inc(&netstamp_needed);
1018}
1019
1020void net_disable_timestamp(void)
1021{
1022 atomic_dec(&netstamp_needed);
1023}
1024
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001025static inline void net_timestamp(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026{
1027 if (atomic_read(&netstamp_needed))
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001028 __net_timestamp(skb);
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001029 else
1030 skb->tstamp.tv64 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031}
1032
1033/*
1034 * Support routine. Sends outgoing frames to any network
1035 * taps currently in use.
1036 */
1037
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001038static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039{
1040 struct packet_type *ptype;
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001041
1042 net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
1044 rcu_read_lock();
1045 list_for_each_entry_rcu(ptype, &ptype_all, list) {
1046 /* Never send packets back to the socket
1047 * they originated from - MvS (miquels@drinkel.ow.org)
1048 */
1049 if ((ptype->dev == dev || !ptype->dev) &&
1050 (ptype->af_packet_priv == NULL ||
1051 (struct sock *)ptype->af_packet_priv != skb->sk)) {
1052 struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1053 if (!skb2)
1054 break;
1055
1056 /* skb->nh should be correctly
1057 set by sender, so that the second statement is
1058 just protection against buggy protocols.
1059 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001060 skb_reset_mac_header(skb2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001062 if (skb_network_header(skb2) < skb2->data ||
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001063 skb2->network_header > skb2->tail) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 if (net_ratelimit())
1065 printk(KERN_CRIT "protocol %04x is "
1066 "buggy, dev %s\n",
1067 skb2->protocol, dev->name);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001068 skb_reset_network_header(skb2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 }
1070
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001071 skb2->transport_header = skb2->network_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 skb2->pkt_type = PACKET_OUTGOING;
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001073 ptype->func(skb2, skb->dev, ptype, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 }
1075 }
1076 rcu_read_unlock();
1077}
1078
Denis Vlasenko56079432006-03-29 15:57:29 -08001079
1080void __netif_schedule(struct net_device *dev)
1081{
1082 if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
1083 unsigned long flags;
1084 struct softnet_data *sd;
1085
1086 local_irq_save(flags);
1087 sd = &__get_cpu_var(softnet_data);
1088 dev->next_sched = sd->output_queue;
1089 sd->output_queue = dev;
1090 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1091 local_irq_restore(flags);
1092 }
1093}
1094EXPORT_SYMBOL(__netif_schedule);
1095
1096void __netif_rx_schedule(struct net_device *dev)
1097{
1098 unsigned long flags;
1099
1100 local_irq_save(flags);
1101 dev_hold(dev);
1102 list_add_tail(&dev->poll_list, &__get_cpu_var(softnet_data).poll_list);
1103 if (dev->quota < 0)
1104 dev->quota += dev->weight;
1105 else
1106 dev->quota = dev->weight;
1107 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
1108 local_irq_restore(flags);
1109}
1110EXPORT_SYMBOL(__netif_rx_schedule);
1111
1112void dev_kfree_skb_any(struct sk_buff *skb)
1113{
1114 if (in_irq() || irqs_disabled())
1115 dev_kfree_skb_irq(skb);
1116 else
1117 dev_kfree_skb(skb);
1118}
1119EXPORT_SYMBOL(dev_kfree_skb_any);
1120
1121
1122/* Hot-plugging. */
1123void netif_device_detach(struct net_device *dev)
1124{
1125 if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1126 netif_running(dev)) {
1127 netif_stop_queue(dev);
1128 }
1129}
1130EXPORT_SYMBOL(netif_device_detach);
1131
1132void netif_device_attach(struct net_device *dev)
1133{
1134 if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1135 netif_running(dev)) {
1136 netif_wake_queue(dev);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001137 __netdev_watchdog_up(dev);
Denis Vlasenko56079432006-03-29 15:57:29 -08001138 }
1139}
1140EXPORT_SYMBOL(netif_device_attach);
1141
1142
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143/*
1144 * Invalidate hardware checksum when packet is to be mangled, and
1145 * complete checksum manually on outgoing path.
1146 */
Patrick McHardy84fa7932006-08-29 16:44:56 -07001147int skb_checksum_help(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148{
Al Virod3bc23e2006-11-14 21:24:49 -08001149 __wsum csum;
Herbert Xu663ead32007-04-09 11:59:07 -07001150 int ret = 0, offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
Patrick McHardy84fa7932006-08-29 16:44:56 -07001152 if (skb->ip_summed == CHECKSUM_COMPLETE)
Herbert Xua430a432006-07-08 13:34:56 -07001153 goto out_set_summed;
1154
1155 if (unlikely(skb_shinfo(skb)->gso_size)) {
Herbert Xua430a432006-07-08 13:34:56 -07001156 /* Let GSO fix up the checksum. */
1157 goto out_set_summed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 }
1159
1160 if (skb_cloned(skb)) {
1161 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1162 if (ret)
1163 goto out;
1164 }
1165
Herbert Xu663ead32007-04-09 11:59:07 -07001166 offset = skb->csum_start - skb_headroom(skb);
Kris Katterjohn09a62662006-01-08 22:24:28 -08001167 BUG_ON(offset > (int)skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 csum = skb_checksum(skb, offset, skb->len-offset, 0);
1169
Herbert Xu663ead32007-04-09 11:59:07 -07001170 offset = skb_headlen(skb) - offset;
Kris Katterjohn09a62662006-01-08 22:24:28 -08001171 BUG_ON(offset <= 0);
Al Viroff1dcad2006-11-20 18:07:29 -08001172 BUG_ON(skb->csum_offset + 2 > offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
Herbert Xu663ead32007-04-09 11:59:07 -07001174 *(__sum16 *)(skb->head + skb->csum_start + skb->csum_offset) =
1175 csum_fold(csum);
Herbert Xua430a432006-07-08 13:34:56 -07001176out_set_summed:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 skb->ip_summed = CHECKSUM_NONE;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001178out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 return ret;
1180}
1181
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001182/**
1183 * skb_gso_segment - Perform segmentation on skb.
1184 * @skb: buffer to segment
Herbert Xu576a30e2006-06-27 13:22:38 -07001185 * @features: features for the output path (see dev->features)
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001186 *
1187 * This function segments the given skb and returns a list of segments.
Herbert Xu576a30e2006-06-27 13:22:38 -07001188 *
1189 * It may return NULL if the skb requires no segmentation. This is
1190 * only possible when GSO is used for verifying header integrity.
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001191 */
Herbert Xu576a30e2006-06-27 13:22:38 -07001192struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001193{
1194 struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1195 struct packet_type *ptype;
Al Viro252e3342006-11-14 20:48:11 -08001196 __be16 type = skb->protocol;
Herbert Xua430a432006-07-08 13:34:56 -07001197 int err;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001198
1199 BUG_ON(skb_shinfo(skb)->frag_list);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001200
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001201 skb_reset_mac_header(skb);
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001202 skb->mac_len = skb->network_header - skb->mac_header;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001203 __skb_pull(skb, skb->mac_len);
1204
Herbert Xuf9d106a2007-04-23 22:36:13 -07001205 if (WARN_ON(skb->ip_summed != CHECKSUM_PARTIAL)) {
Herbert Xua430a432006-07-08 13:34:56 -07001206 if (skb_header_cloned(skb) &&
1207 (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1208 return ERR_PTR(err);
1209 }
1210
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001211 rcu_read_lock();
1212 list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type) & 15], list) {
1213 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
Patrick McHardy84fa7932006-08-29 16:44:56 -07001214 if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
Herbert Xua430a432006-07-08 13:34:56 -07001215 err = ptype->gso_send_check(skb);
1216 segs = ERR_PTR(err);
1217 if (err || skb_gso_ok(skb, features))
1218 break;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001219 __skb_push(skb, (skb->data -
1220 skb_network_header(skb)));
Herbert Xua430a432006-07-08 13:34:56 -07001221 }
Herbert Xu576a30e2006-06-27 13:22:38 -07001222 segs = ptype->gso_segment(skb, features);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001223 break;
1224 }
1225 }
1226 rcu_read_unlock();
1227
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001228 __skb_push(skb, skb->data - skb_mac_header(skb));
Herbert Xu576a30e2006-06-27 13:22:38 -07001229
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001230 return segs;
1231}
1232
1233EXPORT_SYMBOL(skb_gso_segment);
1234
Herbert Xufb286bb2005-11-10 13:01:24 -08001235/* Take action when hardware reception checksum errors are detected. */
1236#ifdef CONFIG_BUG
1237void netdev_rx_csum_fault(struct net_device *dev)
1238{
1239 if (net_ratelimit()) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001240 printk(KERN_ERR "%s: hw csum failure.\n",
Stephen Hemminger246a4212005-12-08 15:21:39 -08001241 dev ? dev->name : "<unknown>");
Herbert Xufb286bb2005-11-10 13:01:24 -08001242 dump_stack();
1243 }
1244}
1245EXPORT_SYMBOL(netdev_rx_csum_fault);
1246#endif
1247
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248/* Actually, we should eliminate this check as soon as we know, that:
1249 * 1. IOMMU is present and allows to map all the memory.
1250 * 2. No high memory really exists on this machine.
1251 */
1252
1253static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1254{
Herbert Xu3d3a8532006-06-27 13:33:10 -07001255#ifdef CONFIG_HIGHMEM
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 int i;
1257
1258 if (dev->features & NETIF_F_HIGHDMA)
1259 return 0;
1260
1261 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1262 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1263 return 1;
1264
Herbert Xu3d3a8532006-06-27 13:33:10 -07001265#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 return 0;
1267}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001269struct dev_gso_cb {
1270 void (*destructor)(struct sk_buff *skb);
1271};
1272
1273#define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1274
1275static void dev_gso_skb_destructor(struct sk_buff *skb)
1276{
1277 struct dev_gso_cb *cb;
1278
1279 do {
1280 struct sk_buff *nskb = skb->next;
1281
1282 skb->next = nskb->next;
1283 nskb->next = NULL;
1284 kfree_skb(nskb);
1285 } while (skb->next);
1286
1287 cb = DEV_GSO_CB(skb);
1288 if (cb->destructor)
1289 cb->destructor(skb);
1290}
1291
1292/**
1293 * dev_gso_segment - Perform emulated hardware segmentation on skb.
1294 * @skb: buffer to segment
1295 *
1296 * This function segments the given skb and stores the list of segments
1297 * in skb->next.
1298 */
1299static int dev_gso_segment(struct sk_buff *skb)
1300{
1301 struct net_device *dev = skb->dev;
1302 struct sk_buff *segs;
Herbert Xu576a30e2006-06-27 13:22:38 -07001303 int features = dev->features & ~(illegal_highdma(dev, skb) ?
1304 NETIF_F_SG : 0);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001305
Herbert Xu576a30e2006-06-27 13:22:38 -07001306 segs = skb_gso_segment(skb, features);
1307
1308 /* Verifying header integrity only. */
1309 if (!segs)
1310 return 0;
1311
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001312 if (unlikely(IS_ERR(segs)))
1313 return PTR_ERR(segs);
1314
1315 skb->next = segs;
1316 DEV_GSO_CB(skb)->destructor = skb->destructor;
1317 skb->destructor = dev_gso_skb_destructor;
1318
1319 return 0;
1320}
1321
1322int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1323{
1324 if (likely(!skb->next)) {
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -07001325 if (!list_empty(&ptype_all))
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001326 dev_queue_xmit_nit(skb, dev);
1327
Herbert Xu576a30e2006-06-27 13:22:38 -07001328 if (netif_needs_gso(dev, skb)) {
1329 if (unlikely(dev_gso_segment(skb)))
1330 goto out_kfree_skb;
1331 if (skb->next)
1332 goto gso;
1333 }
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001334
Herbert Xu576a30e2006-06-27 13:22:38 -07001335 return dev->hard_start_xmit(skb, dev);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001336 }
1337
Herbert Xu576a30e2006-06-27 13:22:38 -07001338gso:
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001339 do {
1340 struct sk_buff *nskb = skb->next;
1341 int rc;
1342
1343 skb->next = nskb->next;
1344 nskb->next = NULL;
1345 rc = dev->hard_start_xmit(nskb, dev);
1346 if (unlikely(rc)) {
Michael Chanf54d9e82006-06-25 23:57:04 -07001347 nskb->next = skb->next;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001348 skb->next = nskb;
1349 return rc;
1350 }
Michael Chanf54d9e82006-06-25 23:57:04 -07001351 if (unlikely(netif_queue_stopped(dev) && skb->next))
1352 return NETDEV_TX_BUSY;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001353 } while (skb->next);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001354
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001355 skb->destructor = DEV_GSO_CB(skb)->destructor;
1356
1357out_kfree_skb:
1358 kfree_skb(skb);
1359 return 0;
1360}
1361
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362#define HARD_TX_LOCK(dev, cpu) { \
1363 if ((dev->features & NETIF_F_LLTX) == 0) { \
Herbert Xu932ff272006-06-09 12:20:56 -07001364 netif_tx_lock(dev); \
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 } \
1366}
1367
1368#define HARD_TX_UNLOCK(dev) { \
1369 if ((dev->features & NETIF_F_LLTX) == 0) { \
Herbert Xu932ff272006-06-09 12:20:56 -07001370 netif_tx_unlock(dev); \
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 } \
1372}
1373
1374/**
1375 * dev_queue_xmit - transmit a buffer
1376 * @skb: buffer to transmit
1377 *
1378 * Queue a buffer for transmission to a network device. The caller must
1379 * have set the device and priority and built the buffer before calling
1380 * this function. The function can be called from an interrupt.
1381 *
1382 * A negative errno code is returned on a failure. A success does not
1383 * guarantee the frame will be transmitted as it may be dropped due
1384 * to congestion or traffic shaping.
Ben Greearaf191362005-04-24 20:12:36 -07001385 *
1386 * -----------------------------------------------------------------------------------
1387 * I notice this method can also return errors from the queue disciplines,
1388 * including NET_XMIT_DROP, which is a positive value. So, errors can also
1389 * be positive.
1390 *
1391 * Regardless of the return value, the skb is consumed, so it is currently
1392 * difficult to retry a send to this method. (You can bump the ref count
1393 * before sending to hold a reference for retry if you are careful.)
1394 *
1395 * When calling this method, interrupts MUST be enabled. This is because
1396 * the BH enable code must have IRQs enabled so that it will not deadlock.
1397 * --BLG
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 */
1399
1400int dev_queue_xmit(struct sk_buff *skb)
1401{
1402 struct net_device *dev = skb->dev;
1403 struct Qdisc *q;
1404 int rc = -ENOMEM;
1405
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001406 /* GSO will handle the following emulations directly. */
1407 if (netif_needs_gso(dev, skb))
1408 goto gso;
1409
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 if (skb_shinfo(skb)->frag_list &&
1411 !(dev->features & NETIF_F_FRAGLIST) &&
Herbert Xu364c6ba2006-06-09 16:10:40 -07001412 __skb_linearize(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 goto out_kfree_skb;
1414
1415 /* Fragmented skb is linearized if device does not support SG,
1416 * or if at least one of fragments is in highmem and device
1417 * does not support DMA from it.
1418 */
1419 if (skb_shinfo(skb)->nr_frags &&
1420 (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
Herbert Xu364c6ba2006-06-09 16:10:40 -07001421 __skb_linearize(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 goto out_kfree_skb;
1423
1424 /* If packet is not checksummed and device does not support
1425 * checksumming for this protocol, complete checksumming here.
1426 */
Herbert Xu663ead32007-04-09 11:59:07 -07001427 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1428 skb_set_transport_header(skb, skb->csum_start -
1429 skb_headroom(skb));
1430
1431 if (!(dev->features & NETIF_F_GEN_CSUM) &&
1432 (!(dev->features & NETIF_F_IP_CSUM) ||
1433 skb->protocol != htons(ETH_P_IP)))
1434 if (skb_checksum_help(skb))
1435 goto out_kfree_skb;
1436 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001438gso:
Eric Dumazet2d7ceec2005-09-27 15:22:58 -07001439 spin_lock_prefetch(&dev->queue_lock);
1440
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001441 /* Disable soft irqs for various locks below. Also
1442 * stops preemption for RCU.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001444 rcu_read_lock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001446 /* Updates of qdisc are serialized by queue_lock.
1447 * The struct Qdisc which is pointed to by qdisc is now a
1448 * rcu structure - it may be accessed without acquiring
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 * a lock (but the structure may be stale.) The freeing of the
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001450 * qdisc will be deferred until it's known that there are no
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 * more references to it.
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001452 *
1453 * If the qdisc has an enqueue function, we still need to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 * hold the queue_lock before calling it, since queue_lock
1455 * also serializes access to the device queue.
1456 */
1457
1458 q = rcu_dereference(dev->qdisc);
1459#ifdef CONFIG_NET_CLS_ACT
1460 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1461#endif
1462 if (q->enqueue) {
1463 /* Grab device queue */
1464 spin_lock(&dev->queue_lock);
Patrick McHardy85670cc2006-09-27 16:45:45 -07001465 q = dev->qdisc;
1466 if (q->enqueue) {
1467 rc = q->enqueue(skb, q);
1468 qdisc_run(dev);
1469 spin_unlock(&dev->queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470
Patrick McHardy85670cc2006-09-27 16:45:45 -07001471 rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
1472 goto out;
1473 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 spin_unlock(&dev->queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 }
1476
1477 /* The device has no queue. Common case for software devices:
1478 loopback, all the sorts of tunnels...
1479
Herbert Xu932ff272006-06-09 12:20:56 -07001480 Really, it is unlikely that netif_tx_lock protection is necessary
1481 here. (f.e. loopback and IP tunnels are clean ignoring statistics
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 counters.)
1483 However, it is possible, that they rely on protection
1484 made by us here.
1485
1486 Check this and shot the lock. It is not prone from deadlocks.
1487 Either shot noqueue qdisc, it is even simpler 8)
1488 */
1489 if (dev->flags & IFF_UP) {
1490 int cpu = smp_processor_id(); /* ok because BHs are off */
1491
1492 if (dev->xmit_lock_owner != cpu) {
1493
1494 HARD_TX_LOCK(dev, cpu);
1495
1496 if (!netif_queue_stopped(dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 rc = 0;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001498 if (!dev_hard_start_xmit(skb, dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 HARD_TX_UNLOCK(dev);
1500 goto out;
1501 }
1502 }
1503 HARD_TX_UNLOCK(dev);
1504 if (net_ratelimit())
1505 printk(KERN_CRIT "Virtual device %s asks to "
1506 "queue packet!\n", dev->name);
1507 } else {
1508 /* Recursion is detected! It is possible,
1509 * unfortunately */
1510 if (net_ratelimit())
1511 printk(KERN_CRIT "Dead loop on virtual device "
1512 "%s, fix it urgently!\n", dev->name);
1513 }
1514 }
1515
1516 rc = -ENETDOWN;
Herbert Xud4828d82006-06-22 02:28:18 -07001517 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518
1519out_kfree_skb:
1520 kfree_skb(skb);
1521 return rc;
1522out:
Herbert Xud4828d82006-06-22 02:28:18 -07001523 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 return rc;
1525}
1526
1527
1528/*=======================================================================
1529 Receiver routines
1530 =======================================================================*/
1531
Stephen Hemminger6b2bedc2007-03-12 14:33:50 -07001532int netdev_max_backlog __read_mostly = 1000;
1533int netdev_budget __read_mostly = 300;
1534int weight_p __read_mostly = 64; /* old backlog weight */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535
1536DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1537
1538
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539/**
1540 * netif_rx - post buffer to the network code
1541 * @skb: buffer to post
1542 *
1543 * This function receives a packet from a device driver and queues it for
1544 * the upper (protocol) levels to process. It always succeeds. The buffer
1545 * may be dropped during processing for congestion control or by the
1546 * protocol layers.
1547 *
1548 * return values:
1549 * NET_RX_SUCCESS (no congestion)
1550 * NET_RX_CN_LOW (low congestion)
1551 * NET_RX_CN_MOD (moderate congestion)
1552 * NET_RX_CN_HIGH (high congestion)
1553 * NET_RX_DROP (packet was dropped)
1554 *
1555 */
1556
1557int netif_rx(struct sk_buff *skb)
1558{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 struct softnet_data *queue;
1560 unsigned long flags;
1561
1562 /* if netpoll wants it, pretend we never saw it */
1563 if (netpoll_rx(skb))
1564 return NET_RX_DROP;
1565
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001566 if (!skb->tstamp.tv64)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001567 net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568
1569 /*
1570 * The code is rearranged so that the path is the most
1571 * short when CPU is congested, but is still operating.
1572 */
1573 local_irq_save(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 queue = &__get_cpu_var(softnet_data);
1575
1576 __get_cpu_var(netdev_rx_stat).total++;
1577 if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1578 if (queue->input_pkt_queue.qlen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579enqueue:
1580 dev_hold(skb->dev);
1581 __skb_queue_tail(&queue->input_pkt_queue, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 local_irq_restore(flags);
Stephen Hemminger34008d82005-06-23 20:10:00 -07001583 return NET_RX_SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 }
1585
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 netif_rx_schedule(&queue->backlog_dev);
1587 goto enqueue;
1588 }
1589
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 __get_cpu_var(netdev_rx_stat).dropped++;
1591 local_irq_restore(flags);
1592
1593 kfree_skb(skb);
1594 return NET_RX_DROP;
1595}
1596
1597int netif_rx_ni(struct sk_buff *skb)
1598{
1599 int err;
1600
1601 preempt_disable();
1602 err = netif_rx(skb);
1603 if (local_softirq_pending())
1604 do_softirq();
1605 preempt_enable();
1606
1607 return err;
1608}
1609
1610EXPORT_SYMBOL(netif_rx_ni);
1611
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001612static inline struct net_device *skb_bond(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613{
1614 struct net_device *dev = skb->dev;
1615
Jay Vosburgh8f903c72006-02-21 16:36:44 -08001616 if (dev->master) {
David S. Miller7ea49ed2006-08-14 17:08:36 -07001617 if (skb_bond_should_drop(skb)) {
Jay Vosburgh8f903c72006-02-21 16:36:44 -08001618 kfree_skb(skb);
1619 return NULL;
1620 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 skb->dev = dev->master;
Jay Vosburgh8f903c72006-02-21 16:36:44 -08001622 }
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001623
1624 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625}
1626
1627static void net_tx_action(struct softirq_action *h)
1628{
1629 struct softnet_data *sd = &__get_cpu_var(softnet_data);
1630
1631 if (sd->completion_queue) {
1632 struct sk_buff *clist;
1633
1634 local_irq_disable();
1635 clist = sd->completion_queue;
1636 sd->completion_queue = NULL;
1637 local_irq_enable();
1638
1639 while (clist) {
1640 struct sk_buff *skb = clist;
1641 clist = clist->next;
1642
1643 BUG_TRAP(!atomic_read(&skb->users));
1644 __kfree_skb(skb);
1645 }
1646 }
1647
1648 if (sd->output_queue) {
1649 struct net_device *head;
1650
1651 local_irq_disable();
1652 head = sd->output_queue;
1653 sd->output_queue = NULL;
1654 local_irq_enable();
1655
1656 while (head) {
1657 struct net_device *dev = head;
1658 head = head->next_sched;
1659
1660 smp_mb__before_clear_bit();
1661 clear_bit(__LINK_STATE_SCHED, &dev->state);
1662
1663 if (spin_trylock(&dev->queue_lock)) {
1664 qdisc_run(dev);
1665 spin_unlock(&dev->queue_lock);
1666 } else {
1667 netif_schedule(dev);
1668 }
1669 }
1670 }
1671}
1672
Stephen Hemminger6f05f622007-03-08 20:46:03 -08001673static inline int deliver_skb(struct sk_buff *skb,
1674 struct packet_type *pt_prev,
1675 struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676{
1677 atomic_inc(&skb->users);
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001678 return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679}
1680
1681#if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
Stephen Hemminger6229e362007-03-21 13:38:47 -07001682/* These hooks defined here for ATM */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683struct net_bridge;
1684struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
1685 unsigned char *addr);
Stephen Hemminger6229e362007-03-21 13:38:47 -07001686void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687
Stephen Hemminger6229e362007-03-21 13:38:47 -07001688/*
1689 * If bridge module is loaded call bridging hook.
1690 * returns NULL if packet was consumed.
1691 */
1692struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
1693 struct sk_buff *skb) __read_mostly;
1694static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
1695 struct packet_type **pt_prev, int *ret,
1696 struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697{
1698 struct net_bridge_port *port;
1699
Stephen Hemminger6229e362007-03-21 13:38:47 -07001700 if (skb->pkt_type == PACKET_LOOPBACK ||
1701 (port = rcu_dereference(skb->dev->br_port)) == NULL)
1702 return skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703
1704 if (*pt_prev) {
Stephen Hemminger6229e362007-03-21 13:38:47 -07001705 *ret = deliver_skb(skb, *pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 *pt_prev = NULL;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001707 }
1708
Stephen Hemminger6229e362007-03-21 13:38:47 -07001709 return br_handle_frame_hook(port, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710}
1711#else
Stephen Hemminger6229e362007-03-21 13:38:47 -07001712#define handle_bridge(skb, pt_prev, ret, orig_dev) (skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713#endif
1714
1715#ifdef CONFIG_NET_CLS_ACT
1716/* TODO: Maybe we should just force sch_ingress to be compiled in
1717 * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
1718 * a compare and 2 stores extra right now if we dont have it on
1719 * but have CONFIG_NET_CLS_ACT
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001720 * NOTE: This doesnt stop any functionality; if you dont have
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 * the ingress scheduler, you just cant add policies on ingress.
1722 *
1723 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001724static int ing_filter(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725{
1726 struct Qdisc *q;
1727 struct net_device *dev = skb->dev;
1728 int result = TC_ACT_OK;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001729
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 if (dev->qdisc_ingress) {
1731 __u32 ttl = (__u32) G_TC_RTTL(skb->tc_verd);
1732 if (MAX_RED_LOOP < ttl++) {
Patrick McHardyc01003c2007-03-29 11:46:52 -07001733 printk(KERN_WARNING "Redir loop detected Dropping packet (%d->%d)\n",
1734 skb->iif, skb->dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 return TC_ACT_SHOT;
1736 }
1737
1738 skb->tc_verd = SET_TC_RTTL(skb->tc_verd,ttl);
1739
1740 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_INGRESS);
David S. Miller86e65da2005-08-09 19:36:29 -07001741
Patrick McHardyfd44de72007-04-16 17:07:08 -07001742 spin_lock(&dev->ingress_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 if ((q = dev->qdisc_ingress) != NULL)
1744 result = q->enqueue(skb, q);
Patrick McHardyfd44de72007-04-16 17:07:08 -07001745 spin_unlock(&dev->ingress_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746
1747 }
1748
1749 return result;
1750}
1751#endif
1752
1753int netif_receive_skb(struct sk_buff *skb)
1754{
1755 struct packet_type *ptype, *pt_prev;
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001756 struct net_device *orig_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 int ret = NET_RX_DROP;
Al Viro252e3342006-11-14 20:48:11 -08001758 __be16 type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759
1760 /* if we've gotten here through NAPI, check netpoll */
1761 if (skb->dev->poll && netpoll_rx(skb))
1762 return NET_RX_DROP;
1763
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001764 if (!skb->tstamp.tv64)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001765 net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766
Patrick McHardyc01003c2007-03-29 11:46:52 -07001767 if (!skb->iif)
1768 skb->iif = skb->dev->ifindex;
David S. Miller86e65da2005-08-09 19:36:29 -07001769
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001770 orig_dev = skb_bond(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771
Jay Vosburgh8f903c72006-02-21 16:36:44 -08001772 if (!orig_dev)
1773 return NET_RX_DROP;
1774
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 __get_cpu_var(netdev_rx_stat).total++;
1776
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001777 skb_reset_network_header(skb);
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001778 skb_reset_transport_header(skb);
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001779 skb->mac_len = skb->network_header - skb->mac_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780
1781 pt_prev = NULL;
1782
1783 rcu_read_lock();
1784
1785#ifdef CONFIG_NET_CLS_ACT
1786 if (skb->tc_verd & TC_NCLS) {
1787 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
1788 goto ncls;
1789 }
1790#endif
1791
1792 list_for_each_entry_rcu(ptype, &ptype_all, list) {
1793 if (!ptype->dev || ptype->dev == skb->dev) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001794 if (pt_prev)
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001795 ret = deliver_skb(skb, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 pt_prev = ptype;
1797 }
1798 }
1799
1800#ifdef CONFIG_NET_CLS_ACT
1801 if (pt_prev) {
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001802 ret = deliver_skb(skb, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 pt_prev = NULL; /* noone else should process this after*/
1804 } else {
1805 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
1806 }
1807
1808 ret = ing_filter(skb);
1809
1810 if (ret == TC_ACT_SHOT || (ret == TC_ACT_STOLEN)) {
1811 kfree_skb(skb);
1812 goto out;
1813 }
1814
1815 skb->tc_verd = 0;
1816ncls:
1817#endif
1818
Stephen Hemminger6229e362007-03-21 13:38:47 -07001819 skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
1820 if (!skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 goto out;
1822
1823 type = skb->protocol;
1824 list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type)&15], list) {
1825 if (ptype->type == type &&
1826 (!ptype->dev || ptype->dev == skb->dev)) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001827 if (pt_prev)
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001828 ret = deliver_skb(skb, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 pt_prev = ptype;
1830 }
1831 }
1832
1833 if (pt_prev) {
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001834 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 } else {
1836 kfree_skb(skb);
1837 /* Jamal, now you will not able to escape explaining
1838 * me how you were going to use this. :-)
1839 */
1840 ret = NET_RX_DROP;
1841 }
1842
1843out:
1844 rcu_read_unlock();
1845 return ret;
1846}
1847
1848static int process_backlog(struct net_device *backlog_dev, int *budget)
1849{
1850 int work = 0;
1851 int quota = min(backlog_dev->quota, *budget);
1852 struct softnet_data *queue = &__get_cpu_var(softnet_data);
1853 unsigned long start_time = jiffies;
1854
Stephen Hemmingere3876602005-06-08 14:56:01 -07001855 backlog_dev->weight = weight_p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 for (;;) {
1857 struct sk_buff *skb;
1858 struct net_device *dev;
1859
1860 local_irq_disable();
1861 skb = __skb_dequeue(&queue->input_pkt_queue);
1862 if (!skb)
1863 goto job_done;
1864 local_irq_enable();
1865
1866 dev = skb->dev;
1867
1868 netif_receive_skb(skb);
1869
1870 dev_put(dev);
1871
1872 work++;
1873
1874 if (work >= quota || jiffies - start_time > 1)
1875 break;
1876
1877 }
1878
1879 backlog_dev->quota -= work;
1880 *budget -= work;
1881 return -1;
1882
1883job_done:
1884 backlog_dev->quota -= work;
1885 *budget -= work;
1886
1887 list_del(&backlog_dev->poll_list);
1888 smp_mb__before_clear_bit();
1889 netif_poll_enable(backlog_dev);
1890
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 local_irq_enable();
1892 return 0;
1893}
1894
1895static void net_rx_action(struct softirq_action *h)
1896{
1897 struct softnet_data *queue = &__get_cpu_var(softnet_data);
1898 unsigned long start_time = jiffies;
Stephen Hemminger51b0bde2005-06-23 20:14:40 -07001899 int budget = netdev_budget;
Matt Mackall53fb95d2005-08-11 19:27:43 -07001900 void *have;
1901
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 local_irq_disable();
1903
1904 while (!list_empty(&queue->poll_list)) {
1905 struct net_device *dev;
1906
1907 if (budget <= 0 || jiffies - start_time > 1)
1908 goto softnet_break;
1909
1910 local_irq_enable();
1911
1912 dev = list_entry(queue->poll_list.next,
1913 struct net_device, poll_list);
Matt Mackall53fb95d2005-08-11 19:27:43 -07001914 have = netpoll_poll_lock(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915
1916 if (dev->quota <= 0 || dev->poll(dev, &budget)) {
Matt Mackall53fb95d2005-08-11 19:27:43 -07001917 netpoll_poll_unlock(have);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 local_irq_disable();
Stephen Hemminger8aca8a22006-03-20 22:26:39 -08001919 list_move_tail(&dev->poll_list, &queue->poll_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 if (dev->quota < 0)
1921 dev->quota += dev->weight;
1922 else
1923 dev->quota = dev->weight;
1924 } else {
Matt Mackall53fb95d2005-08-11 19:27:43 -07001925 netpoll_poll_unlock(have);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 dev_put(dev);
1927 local_irq_disable();
1928 }
1929 }
1930out:
Chris Leechdb217332006-06-17 21:24:58 -07001931#ifdef CONFIG_NET_DMA
1932 /*
1933 * There may not be any more sk_buffs coming right now, so push
1934 * any pending DMA copies to hardware
1935 */
1936 if (net_dma_client) {
1937 struct dma_chan *chan;
1938 rcu_read_lock();
1939 list_for_each_entry_rcu(chan, &net_dma_client->channels, client_node)
1940 dma_async_memcpy_issue_pending(chan);
1941 rcu_read_unlock();
1942 }
1943#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 local_irq_enable();
1945 return;
1946
1947softnet_break:
1948 __get_cpu_var(netdev_rx_stat).time_squeeze++;
1949 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
1950 goto out;
1951}
1952
1953static gifconf_func_t * gifconf_list [NPROTO];
1954
1955/**
1956 * register_gifconf - register a SIOCGIF handler
1957 * @family: Address family
1958 * @gifconf: Function handler
1959 *
1960 * Register protocol dependent address dumping routines. The handler
1961 * that is passed must not be freed or reused until it has been replaced
1962 * by another handler.
1963 */
1964int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
1965{
1966 if (family >= NPROTO)
1967 return -EINVAL;
1968 gifconf_list[family] = gifconf;
1969 return 0;
1970}
1971
1972
1973/*
1974 * Map an interface index to its name (SIOCGIFNAME)
1975 */
1976
1977/*
1978 * We need this ioctl for efficient implementation of the
1979 * if_indextoname() function required by the IPv6 API. Without
1980 * it, we would have to search all the interfaces to find a
1981 * match. --pb
1982 */
1983
1984static int dev_ifname(struct ifreq __user *arg)
1985{
1986 struct net_device *dev;
1987 struct ifreq ifr;
1988
1989 /*
1990 * Fetch the caller's info block.
1991 */
1992
1993 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
1994 return -EFAULT;
1995
1996 read_lock(&dev_base_lock);
1997 dev = __dev_get_by_index(ifr.ifr_ifindex);
1998 if (!dev) {
1999 read_unlock(&dev_base_lock);
2000 return -ENODEV;
2001 }
2002
2003 strcpy(ifr.ifr_name, dev->name);
2004 read_unlock(&dev_base_lock);
2005
2006 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2007 return -EFAULT;
2008 return 0;
2009}
2010
2011/*
2012 * Perform a SIOCGIFCONF call. This structure will change
2013 * size eventually, and there is nothing I can do about it.
2014 * Thus we will need a 'compatibility mode'.
2015 */
2016
2017static int dev_ifconf(char __user *arg)
2018{
2019 struct ifconf ifc;
2020 struct net_device *dev;
2021 char __user *pos;
2022 int len;
2023 int total;
2024 int i;
2025
2026 /*
2027 * Fetch the caller's info block.
2028 */
2029
2030 if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2031 return -EFAULT;
2032
2033 pos = ifc.ifc_buf;
2034 len = ifc.ifc_len;
2035
2036 /*
2037 * Loop over the interfaces, and write an info block for each.
2038 */
2039
2040 total = 0;
2041 for (dev = dev_base; dev; dev = dev->next) {
2042 for (i = 0; i < NPROTO; i++) {
2043 if (gifconf_list[i]) {
2044 int done;
2045 if (!pos)
2046 done = gifconf_list[i](dev, NULL, 0);
2047 else
2048 done = gifconf_list[i](dev, pos + total,
2049 len - total);
2050 if (done < 0)
2051 return -EFAULT;
2052 total += done;
2053 }
2054 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002055 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056
2057 /*
2058 * All done. Write the updated control block back to the caller.
2059 */
2060 ifc.ifc_len = total;
2061
2062 /*
2063 * Both BSD and Solaris return 0 here, so we do too.
2064 */
2065 return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2066}
2067
2068#ifdef CONFIG_PROC_FS
2069/*
2070 * This is invoked by the /proc filesystem handler to display a device
2071 * in detail.
2072 */
Stephen Hemminger6f05f622007-03-08 20:46:03 -08002073static struct net_device *dev_get_idx(loff_t pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074{
2075 struct net_device *dev;
2076 loff_t i;
2077
2078 for (i = 0, dev = dev_base; dev && i < pos; ++i, dev = dev->next);
2079
2080 return i == pos ? dev : NULL;
2081}
2082
2083void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2084{
2085 read_lock(&dev_base_lock);
2086 return *pos ? dev_get_idx(*pos - 1) : SEQ_START_TOKEN;
2087}
2088
2089void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2090{
2091 ++*pos;
2092 return v == SEQ_START_TOKEN ? dev_base : ((struct net_device *)v)->next;
2093}
2094
2095void dev_seq_stop(struct seq_file *seq, void *v)
2096{
2097 read_unlock(&dev_base_lock);
2098}
2099
2100static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2101{
Rusty Russellc45d2862007-03-28 14:29:08 -07002102 struct net_device_stats *stats = dev->get_stats(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103
Rusty Russell5a1b5892007-04-28 21:04:03 -07002104 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2105 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2106 dev->name, stats->rx_bytes, stats->rx_packets,
2107 stats->rx_errors,
2108 stats->rx_dropped + stats->rx_missed_errors,
2109 stats->rx_fifo_errors,
2110 stats->rx_length_errors + stats->rx_over_errors +
2111 stats->rx_crc_errors + stats->rx_frame_errors,
2112 stats->rx_compressed, stats->multicast,
2113 stats->tx_bytes, stats->tx_packets,
2114 stats->tx_errors, stats->tx_dropped,
2115 stats->tx_fifo_errors, stats->collisions,
2116 stats->tx_carrier_errors +
2117 stats->tx_aborted_errors +
2118 stats->tx_window_errors +
2119 stats->tx_heartbeat_errors,
2120 stats->tx_compressed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121}
2122
2123/*
2124 * Called from the PROCfs module. This now uses the new arbitrary sized
2125 * /proc/net interface to create /proc/net/dev
2126 */
2127static int dev_seq_show(struct seq_file *seq, void *v)
2128{
2129 if (v == SEQ_START_TOKEN)
2130 seq_puts(seq, "Inter-| Receive "
2131 " | Transmit\n"
2132 " face |bytes packets errs drop fifo frame "
2133 "compressed multicast|bytes packets errs "
2134 "drop fifo colls carrier compressed\n");
2135 else
2136 dev_seq_printf_stats(seq, v);
2137 return 0;
2138}
2139
2140static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2141{
2142 struct netif_rx_stats *rc = NULL;
2143
2144 while (*pos < NR_CPUS)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002145 if (cpu_online(*pos)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146 rc = &per_cpu(netdev_rx_stat, *pos);
2147 break;
2148 } else
2149 ++*pos;
2150 return rc;
2151}
2152
2153static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2154{
2155 return softnet_get_online(pos);
2156}
2157
2158static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2159{
2160 ++*pos;
2161 return softnet_get_online(pos);
2162}
2163
2164static void softnet_seq_stop(struct seq_file *seq, void *v)
2165{
2166}
2167
2168static int softnet_seq_show(struct seq_file *seq, void *v)
2169{
2170 struct netif_rx_stats *s = v;
2171
2172 seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
Stephen Hemminger31aa02c2005-06-23 20:12:48 -07002173 s->total, s->dropped, s->time_squeeze, 0,
Stephen Hemmingerc1ebcdb2005-06-23 20:08:59 -07002174 0, 0, 0, 0, /* was fastroute */
2175 s->cpu_collision );
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176 return 0;
2177}
2178
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002179static const struct seq_operations dev_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 .start = dev_seq_start,
2181 .next = dev_seq_next,
2182 .stop = dev_seq_stop,
2183 .show = dev_seq_show,
2184};
2185
2186static int dev_seq_open(struct inode *inode, struct file *file)
2187{
2188 return seq_open(file, &dev_seq_ops);
2189}
2190
Arjan van de Ven9a321442007-02-12 00:55:35 -08002191static const struct file_operations dev_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 .owner = THIS_MODULE,
2193 .open = dev_seq_open,
2194 .read = seq_read,
2195 .llseek = seq_lseek,
2196 .release = seq_release,
2197};
2198
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002199static const struct seq_operations softnet_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 .start = softnet_seq_start,
2201 .next = softnet_seq_next,
2202 .stop = softnet_seq_stop,
2203 .show = softnet_seq_show,
2204};
2205
2206static int softnet_seq_open(struct inode *inode, struct file *file)
2207{
2208 return seq_open(file, &softnet_seq_ops);
2209}
2210
Arjan van de Ven9a321442007-02-12 00:55:35 -08002211static const struct file_operations softnet_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212 .owner = THIS_MODULE,
2213 .open = softnet_seq_open,
2214 .read = seq_read,
2215 .llseek = seq_lseek,
2216 .release = seq_release,
2217};
2218
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002219static void *ptype_get_idx(loff_t pos)
2220{
2221 struct packet_type *pt = NULL;
2222 loff_t i = 0;
2223 int t;
2224
2225 list_for_each_entry_rcu(pt, &ptype_all, list) {
2226 if (i == pos)
2227 return pt;
2228 ++i;
2229 }
2230
2231 for (t = 0; t < 16; t++) {
2232 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
2233 if (i == pos)
2234 return pt;
2235 ++i;
2236 }
2237 }
2238 return NULL;
2239}
2240
2241static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
2242{
2243 rcu_read_lock();
2244 return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
2245}
2246
2247static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2248{
2249 struct packet_type *pt;
2250 struct list_head *nxt;
2251 int hash;
2252
2253 ++*pos;
2254 if (v == SEQ_START_TOKEN)
2255 return ptype_get_idx(0);
2256
2257 pt = v;
2258 nxt = pt->list.next;
2259 if (pt->type == htons(ETH_P_ALL)) {
2260 if (nxt != &ptype_all)
2261 goto found;
2262 hash = 0;
2263 nxt = ptype_base[0].next;
2264 } else
2265 hash = ntohs(pt->type) & 15;
2266
2267 while (nxt == &ptype_base[hash]) {
2268 if (++hash >= 16)
2269 return NULL;
2270 nxt = ptype_base[hash].next;
2271 }
2272found:
2273 return list_entry(nxt, struct packet_type, list);
2274}
2275
2276static void ptype_seq_stop(struct seq_file *seq, void *v)
2277{
2278 rcu_read_unlock();
2279}
2280
2281static void ptype_seq_decode(struct seq_file *seq, void *sym)
2282{
2283#ifdef CONFIG_KALLSYMS
2284 unsigned long offset = 0, symsize;
2285 const char *symname;
2286 char *modname;
2287 char namebuf[128];
2288
2289 symname = kallsyms_lookup((unsigned long)sym, &symsize, &offset,
2290 &modname, namebuf);
2291
2292 if (symname) {
2293 char *delim = ":";
2294
2295 if (!modname)
2296 modname = delim = "";
2297 seq_printf(seq, "%s%s%s%s+0x%lx", delim, modname, delim,
2298 symname, offset);
2299 return;
2300 }
2301#endif
2302
2303 seq_printf(seq, "[%p]", sym);
2304}
2305
2306static int ptype_seq_show(struct seq_file *seq, void *v)
2307{
2308 struct packet_type *pt = v;
2309
2310 if (v == SEQ_START_TOKEN)
2311 seq_puts(seq, "Type Device Function\n");
2312 else {
2313 if (pt->type == htons(ETH_P_ALL))
2314 seq_puts(seq, "ALL ");
2315 else
2316 seq_printf(seq, "%04x", ntohs(pt->type));
2317
2318 seq_printf(seq, " %-8s ",
2319 pt->dev ? pt->dev->name : "");
2320 ptype_seq_decode(seq, pt->func);
2321 seq_putc(seq, '\n');
2322 }
2323
2324 return 0;
2325}
2326
2327static const struct seq_operations ptype_seq_ops = {
2328 .start = ptype_seq_start,
2329 .next = ptype_seq_next,
2330 .stop = ptype_seq_stop,
2331 .show = ptype_seq_show,
2332};
2333
2334static int ptype_seq_open(struct inode *inode, struct file *file)
2335{
2336 return seq_open(file, &ptype_seq_ops);
2337}
2338
2339static const struct file_operations ptype_seq_fops = {
2340 .owner = THIS_MODULE,
2341 .open = ptype_seq_open,
2342 .read = seq_read,
2343 .llseek = seq_lseek,
2344 .release = seq_release,
2345};
2346
2347
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348static int __init dev_proc_init(void)
2349{
2350 int rc = -ENOMEM;
2351
2352 if (!proc_net_fops_create("dev", S_IRUGO, &dev_seq_fops))
2353 goto out;
2354 if (!proc_net_fops_create("softnet_stat", S_IRUGO, &softnet_seq_fops))
2355 goto out_dev;
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002356 if (!proc_net_fops_create("ptype", S_IRUGO, &ptype_seq_fops))
2357 goto out_dev2;
2358
Johannes Berg295f4a12007-04-26 20:43:56 -07002359 if (wext_proc_init())
Linus Torvalds1da177e2005-04-16 15:20:36 -07002360 goto out_softnet;
2361 rc = 0;
2362out:
2363 return rc;
2364out_softnet:
2365 proc_net_remove("softnet_stat");
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002366out_dev2:
2367 proc_net_remove("ptype");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368out_dev:
2369 proc_net_remove("dev");
2370 goto out;
2371}
2372#else
2373#define dev_proc_init() 0
2374#endif /* CONFIG_PROC_FS */
2375
2376
2377/**
2378 * netdev_set_master - set up master/slave pair
2379 * @slave: slave device
2380 * @master: new master device
2381 *
2382 * Changes the master device of the slave. Pass %NULL to break the
2383 * bonding. The caller must hold the RTNL semaphore. On a failure
2384 * a negative errno code is returned. On success the reference counts
2385 * are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2386 * function returns zero.
2387 */
2388int netdev_set_master(struct net_device *slave, struct net_device *master)
2389{
2390 struct net_device *old = slave->master;
2391
2392 ASSERT_RTNL();
2393
2394 if (master) {
2395 if (old)
2396 return -EBUSY;
2397 dev_hold(master);
2398 }
2399
2400 slave->master = master;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002401
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402 synchronize_net();
2403
2404 if (old)
2405 dev_put(old);
2406
2407 if (master)
2408 slave->flags |= IFF_SLAVE;
2409 else
2410 slave->flags &= ~IFF_SLAVE;
2411
2412 rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2413 return 0;
2414}
2415
2416/**
2417 * dev_set_promiscuity - update promiscuity count on a device
2418 * @dev: device
2419 * @inc: modifier
2420 *
Stephen Hemminger3041a062006-05-26 13:25:24 -07002421 * Add or remove promiscuity from a device. While the count in the device
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422 * remains above zero the interface remains promiscuous. Once it hits zero
2423 * the device reverts back to normal filtering operation. A negative inc
2424 * value is used to drop promiscuity on the device.
2425 */
2426void dev_set_promiscuity(struct net_device *dev, int inc)
2427{
2428 unsigned short old_flags = dev->flags;
2429
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430 if ((dev->promiscuity += inc) == 0)
2431 dev->flags &= ~IFF_PROMISC;
David Chau52609c02005-07-05 15:11:06 -07002432 else
2433 dev->flags |= IFF_PROMISC;
2434 if (dev->flags != old_flags) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435 dev_mc_upload(dev);
2436 printk(KERN_INFO "device %s %s promiscuous mode\n",
2437 dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002438 "left");
Steve Grubb5bdb9882005-12-03 08:39:35 -05002439 audit_log(current->audit_context, GFP_ATOMIC,
2440 AUDIT_ANOM_PROMISCUOUS,
2441 "dev=%s prom=%d old_prom=%d auid=%u",
2442 dev->name, (dev->flags & IFF_PROMISC),
2443 (old_flags & IFF_PROMISC),
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002444 audit_get_loginuid(current->audit_context));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 }
2446}
2447
2448/**
2449 * dev_set_allmulti - update allmulti count on a device
2450 * @dev: device
2451 * @inc: modifier
2452 *
2453 * Add or remove reception of all multicast frames to a device. While the
2454 * count in the device remains above zero the interface remains listening
2455 * to all interfaces. Once it hits zero the device reverts back to normal
2456 * filtering operation. A negative @inc value is used to drop the counter
2457 * when releasing a resource needing all multicasts.
2458 */
2459
2460void dev_set_allmulti(struct net_device *dev, int inc)
2461{
2462 unsigned short old_flags = dev->flags;
2463
2464 dev->flags |= IFF_ALLMULTI;
2465 if ((dev->allmulti += inc) == 0)
2466 dev->flags &= ~IFF_ALLMULTI;
2467 if (dev->flags ^ old_flags)
2468 dev_mc_upload(dev);
2469}
2470
2471unsigned dev_get_flags(const struct net_device *dev)
2472{
2473 unsigned flags;
2474
2475 flags = (dev->flags & ~(IFF_PROMISC |
2476 IFF_ALLMULTI |
Stefan Rompfb00055a2006-03-20 17:09:11 -08002477 IFF_RUNNING |
2478 IFF_LOWER_UP |
2479 IFF_DORMANT)) |
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480 (dev->gflags & (IFF_PROMISC |
2481 IFF_ALLMULTI));
2482
Stefan Rompfb00055a2006-03-20 17:09:11 -08002483 if (netif_running(dev)) {
2484 if (netif_oper_up(dev))
2485 flags |= IFF_RUNNING;
2486 if (netif_carrier_ok(dev))
2487 flags |= IFF_LOWER_UP;
2488 if (netif_dormant(dev))
2489 flags |= IFF_DORMANT;
2490 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491
2492 return flags;
2493}
2494
2495int dev_change_flags(struct net_device *dev, unsigned flags)
2496{
2497 int ret;
2498 int old_flags = dev->flags;
2499
2500 /*
2501 * Set the flags on our device.
2502 */
2503
2504 dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
2505 IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
2506 IFF_AUTOMEDIA)) |
2507 (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
2508 IFF_ALLMULTI));
2509
2510 /*
2511 * Load in the correct multicast list now the flags have changed.
2512 */
2513
2514 dev_mc_upload(dev);
2515
2516 /*
2517 * Have we downed the interface. We handle IFF_UP ourselves
2518 * according to user attempts to set it, rather than blindly
2519 * setting it.
2520 */
2521
2522 ret = 0;
2523 if ((old_flags ^ flags) & IFF_UP) { /* Bit is different ? */
2524 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
2525
2526 if (!ret)
2527 dev_mc_upload(dev);
2528 }
2529
2530 if (dev->flags & IFF_UP &&
2531 ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
2532 IFF_VOLATILE)))
Alan Sternf07d5b92006-05-09 15:23:03 -07002533 raw_notifier_call_chain(&netdev_chain,
Alan Sterne041c682006-03-27 01:16:30 -08002534 NETDEV_CHANGE, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535
2536 if ((flags ^ dev->gflags) & IFF_PROMISC) {
2537 int inc = (flags & IFF_PROMISC) ? +1 : -1;
2538 dev->gflags ^= IFF_PROMISC;
2539 dev_set_promiscuity(dev, inc);
2540 }
2541
2542 /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
2543 is important. Some (broken) drivers set IFF_PROMISC, when
2544 IFF_ALLMULTI is requested not asking us and not reporting.
2545 */
2546 if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
2547 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
2548 dev->gflags ^= IFF_ALLMULTI;
2549 dev_set_allmulti(dev, inc);
2550 }
2551
2552 if (old_flags ^ dev->flags)
2553 rtmsg_ifinfo(RTM_NEWLINK, dev, old_flags ^ dev->flags);
2554
2555 return ret;
2556}
2557
2558int dev_set_mtu(struct net_device *dev, int new_mtu)
2559{
2560 int err;
2561
2562 if (new_mtu == dev->mtu)
2563 return 0;
2564
2565 /* MTU must be positive. */
2566 if (new_mtu < 0)
2567 return -EINVAL;
2568
2569 if (!netif_device_present(dev))
2570 return -ENODEV;
2571
2572 err = 0;
2573 if (dev->change_mtu)
2574 err = dev->change_mtu(dev, new_mtu);
2575 else
2576 dev->mtu = new_mtu;
2577 if (!err && dev->flags & IFF_UP)
Alan Sternf07d5b92006-05-09 15:23:03 -07002578 raw_notifier_call_chain(&netdev_chain,
Alan Sterne041c682006-03-27 01:16:30 -08002579 NETDEV_CHANGEMTU, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 return err;
2581}
2582
2583int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
2584{
2585 int err;
2586
2587 if (!dev->set_mac_address)
2588 return -EOPNOTSUPP;
2589 if (sa->sa_family != dev->type)
2590 return -EINVAL;
2591 if (!netif_device_present(dev))
2592 return -ENODEV;
2593 err = dev->set_mac_address(dev, sa);
2594 if (!err)
Alan Sternf07d5b92006-05-09 15:23:03 -07002595 raw_notifier_call_chain(&netdev_chain,
Alan Sterne041c682006-03-27 01:16:30 -08002596 NETDEV_CHANGEADDR, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597 return err;
2598}
2599
2600/*
2601 * Perform the SIOCxIFxxx calls.
2602 */
2603static int dev_ifsioc(struct ifreq *ifr, unsigned int cmd)
2604{
2605 int err;
2606 struct net_device *dev = __dev_get_by_name(ifr->ifr_name);
2607
2608 if (!dev)
2609 return -ENODEV;
2610
2611 switch (cmd) {
2612 case SIOCGIFFLAGS: /* Get interface flags */
2613 ifr->ifr_flags = dev_get_flags(dev);
2614 return 0;
2615
2616 case SIOCSIFFLAGS: /* Set interface flags */
2617 return dev_change_flags(dev, ifr->ifr_flags);
2618
2619 case SIOCGIFMETRIC: /* Get the metric on the interface
2620 (currently unused) */
2621 ifr->ifr_metric = 0;
2622 return 0;
2623
2624 case SIOCSIFMETRIC: /* Set the metric on the interface
2625 (currently unused) */
2626 return -EOPNOTSUPP;
2627
2628 case SIOCGIFMTU: /* Get the MTU of a device */
2629 ifr->ifr_mtu = dev->mtu;
2630 return 0;
2631
2632 case SIOCSIFMTU: /* Set the MTU of a device */
2633 return dev_set_mtu(dev, ifr->ifr_mtu);
2634
2635 case SIOCGIFHWADDR:
2636 if (!dev->addr_len)
2637 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
2638 else
2639 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
2640 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
2641 ifr->ifr_hwaddr.sa_family = dev->type;
2642 return 0;
2643
2644 case SIOCSIFHWADDR:
2645 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
2646
2647 case SIOCSIFHWBROADCAST:
2648 if (ifr->ifr_hwaddr.sa_family != dev->type)
2649 return -EINVAL;
2650 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
2651 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
Alan Sternf07d5b92006-05-09 15:23:03 -07002652 raw_notifier_call_chain(&netdev_chain,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653 NETDEV_CHANGEADDR, dev);
2654 return 0;
2655
2656 case SIOCGIFMAP:
2657 ifr->ifr_map.mem_start = dev->mem_start;
2658 ifr->ifr_map.mem_end = dev->mem_end;
2659 ifr->ifr_map.base_addr = dev->base_addr;
2660 ifr->ifr_map.irq = dev->irq;
2661 ifr->ifr_map.dma = dev->dma;
2662 ifr->ifr_map.port = dev->if_port;
2663 return 0;
2664
2665 case SIOCSIFMAP:
2666 if (dev->set_config) {
2667 if (!netif_device_present(dev))
2668 return -ENODEV;
2669 return dev->set_config(dev, &ifr->ifr_map);
2670 }
2671 return -EOPNOTSUPP;
2672
2673 case SIOCADDMULTI:
2674 if (!dev->set_multicast_list ||
2675 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
2676 return -EINVAL;
2677 if (!netif_device_present(dev))
2678 return -ENODEV;
2679 return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
2680 dev->addr_len, 1);
2681
2682 case SIOCDELMULTI:
2683 if (!dev->set_multicast_list ||
2684 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
2685 return -EINVAL;
2686 if (!netif_device_present(dev))
2687 return -ENODEV;
2688 return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
2689 dev->addr_len, 1);
2690
2691 case SIOCGIFINDEX:
2692 ifr->ifr_ifindex = dev->ifindex;
2693 return 0;
2694
2695 case SIOCGIFTXQLEN:
2696 ifr->ifr_qlen = dev->tx_queue_len;
2697 return 0;
2698
2699 case SIOCSIFTXQLEN:
2700 if (ifr->ifr_qlen < 0)
2701 return -EINVAL;
2702 dev->tx_queue_len = ifr->ifr_qlen;
2703 return 0;
2704
2705 case SIOCSIFNAME:
2706 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
2707 return dev_change_name(dev, ifr->ifr_newname);
2708
2709 /*
2710 * Unknown or private ioctl
2711 */
2712
2713 default:
2714 if ((cmd >= SIOCDEVPRIVATE &&
2715 cmd <= SIOCDEVPRIVATE + 15) ||
2716 cmd == SIOCBONDENSLAVE ||
2717 cmd == SIOCBONDRELEASE ||
2718 cmd == SIOCBONDSETHWADDR ||
2719 cmd == SIOCBONDSLAVEINFOQUERY ||
2720 cmd == SIOCBONDINFOQUERY ||
2721 cmd == SIOCBONDCHANGEACTIVE ||
2722 cmd == SIOCGMIIPHY ||
2723 cmd == SIOCGMIIREG ||
2724 cmd == SIOCSMIIREG ||
2725 cmd == SIOCBRADDIF ||
2726 cmd == SIOCBRDELIF ||
2727 cmd == SIOCWANDEV) {
2728 err = -EOPNOTSUPP;
2729 if (dev->do_ioctl) {
2730 if (netif_device_present(dev))
2731 err = dev->do_ioctl(dev, ifr,
2732 cmd);
2733 else
2734 err = -ENODEV;
2735 }
2736 } else
2737 err = -EINVAL;
2738
2739 }
2740 return err;
2741}
2742
2743/*
2744 * This function handles all "interface"-type I/O control requests. The actual
2745 * 'doing' part of this is dev_ifsioc above.
2746 */
2747
2748/**
2749 * dev_ioctl - network device ioctl
2750 * @cmd: command to issue
2751 * @arg: pointer to a struct ifreq in user space
2752 *
2753 * Issue ioctl functions to devices. This is normally called by the
2754 * user space syscall interfaces but can sometimes be useful for
2755 * other purposes. The return value is the return from the syscall if
2756 * positive or a negative errno code on error.
2757 */
2758
2759int dev_ioctl(unsigned int cmd, void __user *arg)
2760{
2761 struct ifreq ifr;
2762 int ret;
2763 char *colon;
2764
2765 /* One special case: SIOCGIFCONF takes ifconf argument
2766 and requires shared lock, because it sleeps writing
2767 to user space.
2768 */
2769
2770 if (cmd == SIOCGIFCONF) {
Stephen Hemminger6756ae42006-03-20 22:23:58 -08002771 rtnl_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772 ret = dev_ifconf((char __user *) arg);
Stephen Hemminger6756ae42006-03-20 22:23:58 -08002773 rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774 return ret;
2775 }
2776 if (cmd == SIOCGIFNAME)
2777 return dev_ifname((struct ifreq __user *)arg);
2778
2779 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2780 return -EFAULT;
2781
2782 ifr.ifr_name[IFNAMSIZ-1] = 0;
2783
2784 colon = strchr(ifr.ifr_name, ':');
2785 if (colon)
2786 *colon = 0;
2787
2788 /*
2789 * See which interface the caller is talking about.
2790 */
2791
2792 switch (cmd) {
2793 /*
2794 * These ioctl calls:
2795 * - can be done by all.
2796 * - atomic and do not require locking.
2797 * - return a value
2798 */
2799 case SIOCGIFFLAGS:
2800 case SIOCGIFMETRIC:
2801 case SIOCGIFMTU:
2802 case SIOCGIFHWADDR:
2803 case SIOCGIFSLAVE:
2804 case SIOCGIFMAP:
2805 case SIOCGIFINDEX:
2806 case SIOCGIFTXQLEN:
2807 dev_load(ifr.ifr_name);
2808 read_lock(&dev_base_lock);
2809 ret = dev_ifsioc(&ifr, cmd);
2810 read_unlock(&dev_base_lock);
2811 if (!ret) {
2812 if (colon)
2813 *colon = ':';
2814 if (copy_to_user(arg, &ifr,
2815 sizeof(struct ifreq)))
2816 ret = -EFAULT;
2817 }
2818 return ret;
2819
2820 case SIOCETHTOOL:
2821 dev_load(ifr.ifr_name);
2822 rtnl_lock();
2823 ret = dev_ethtool(&ifr);
2824 rtnl_unlock();
2825 if (!ret) {
2826 if (colon)
2827 *colon = ':';
2828 if (copy_to_user(arg, &ifr,
2829 sizeof(struct ifreq)))
2830 ret = -EFAULT;
2831 }
2832 return ret;
2833
2834 /*
2835 * These ioctl calls:
2836 * - require superuser power.
2837 * - require strict serialization.
2838 * - return a value
2839 */
2840 case SIOCGMIIPHY:
2841 case SIOCGMIIREG:
2842 case SIOCSIFNAME:
2843 if (!capable(CAP_NET_ADMIN))
2844 return -EPERM;
2845 dev_load(ifr.ifr_name);
2846 rtnl_lock();
2847 ret = dev_ifsioc(&ifr, cmd);
2848 rtnl_unlock();
2849 if (!ret) {
2850 if (colon)
2851 *colon = ':';
2852 if (copy_to_user(arg, &ifr,
2853 sizeof(struct ifreq)))
2854 ret = -EFAULT;
2855 }
2856 return ret;
2857
2858 /*
2859 * These ioctl calls:
2860 * - require superuser power.
2861 * - require strict serialization.
2862 * - do not return a value
2863 */
2864 case SIOCSIFFLAGS:
2865 case SIOCSIFMETRIC:
2866 case SIOCSIFMTU:
2867 case SIOCSIFMAP:
2868 case SIOCSIFHWADDR:
2869 case SIOCSIFSLAVE:
2870 case SIOCADDMULTI:
2871 case SIOCDELMULTI:
2872 case SIOCSIFHWBROADCAST:
2873 case SIOCSIFTXQLEN:
2874 case SIOCSMIIREG:
2875 case SIOCBONDENSLAVE:
2876 case SIOCBONDRELEASE:
2877 case SIOCBONDSETHWADDR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878 case SIOCBONDCHANGEACTIVE:
2879 case SIOCBRADDIF:
2880 case SIOCBRDELIF:
2881 if (!capable(CAP_NET_ADMIN))
2882 return -EPERM;
Thomas Grafcabcac02006-01-24 12:46:33 -08002883 /* fall through */
2884 case SIOCBONDSLAVEINFOQUERY:
2885 case SIOCBONDINFOQUERY:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886 dev_load(ifr.ifr_name);
2887 rtnl_lock();
2888 ret = dev_ifsioc(&ifr, cmd);
2889 rtnl_unlock();
2890 return ret;
2891
2892 case SIOCGIFMEM:
2893 /* Get the per device memory space. We can add this but
2894 * currently do not support it */
2895 case SIOCSIFMEM:
2896 /* Set the per device memory buffer space.
2897 * Not applicable in our case */
2898 case SIOCSIFLINK:
2899 return -EINVAL;
2900
2901 /*
2902 * Unknown or private ioctl.
2903 */
2904 default:
2905 if (cmd == SIOCWANDEV ||
2906 (cmd >= SIOCDEVPRIVATE &&
2907 cmd <= SIOCDEVPRIVATE + 15)) {
2908 dev_load(ifr.ifr_name);
2909 rtnl_lock();
2910 ret = dev_ifsioc(&ifr, cmd);
2911 rtnl_unlock();
2912 if (!ret && copy_to_user(arg, &ifr,
2913 sizeof(struct ifreq)))
2914 ret = -EFAULT;
2915 return ret;
2916 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917 /* Take care of Wireless Extensions */
Johannes Berg295f4a12007-04-26 20:43:56 -07002918 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
2919 return wext_handle_ioctl(&ifr, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920 return -EINVAL;
2921 }
2922}
2923
2924
2925/**
2926 * dev_new_index - allocate an ifindex
2927 *
2928 * Returns a suitable unique value for a new device interface
2929 * number. The caller must hold the rtnl semaphore or the
2930 * dev_base_lock to be sure it remains unique.
2931 */
2932static int dev_new_index(void)
2933{
2934 static int ifindex;
2935 for (;;) {
2936 if (++ifindex <= 0)
2937 ifindex = 1;
2938 if (!__dev_get_by_index(ifindex))
2939 return ifindex;
2940 }
2941}
2942
2943static int dev_boot_phase = 1;
2944
2945/* Delayed registration/unregisteration */
2946static DEFINE_SPINLOCK(net_todo_list_lock);
2947static struct list_head net_todo_list = LIST_HEAD_INIT(net_todo_list);
2948
Stephen Hemminger6f05f622007-03-08 20:46:03 -08002949static void net_set_todo(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002950{
2951 spin_lock(&net_todo_list_lock);
2952 list_add_tail(&dev->todo_list, &net_todo_list);
2953 spin_unlock(&net_todo_list_lock);
2954}
2955
2956/**
2957 * register_netdevice - register a network device
2958 * @dev: device to register
2959 *
2960 * Take a completed network device structure and add it to the kernel
2961 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
2962 * chain. 0 is returned on success. A negative errno code is returned
2963 * on a failure to set up the device, or if the name is a duplicate.
2964 *
2965 * Callers must hold the rtnl semaphore. You may want
2966 * register_netdev() instead of this.
2967 *
2968 * BUGS:
2969 * The locking appears insufficient to guarantee two parallel registers
2970 * will not get the same name.
2971 */
2972
2973int register_netdevice(struct net_device *dev)
2974{
2975 struct hlist_head *head;
2976 struct hlist_node *p;
2977 int ret;
2978
2979 BUG_ON(dev_boot_phase);
2980 ASSERT_RTNL();
2981
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07002982 might_sleep();
2983
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 /* When net_device's are persistent, this will be fatal. */
2985 BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
2986
2987 spin_lock_init(&dev->queue_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07002988 spin_lock_init(&dev->_xmit_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002989 dev->xmit_lock_owner = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002990 spin_lock_init(&dev->ingress_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991
Linus Torvalds1da177e2005-04-16 15:20:36 -07002992 dev->iflink = -1;
2993
2994 /* Init, if this function is available */
2995 if (dev->init) {
2996 ret = dev->init(dev);
2997 if (ret) {
2998 if (ret > 0)
2999 ret = -EIO;
Adrian Bunk90833aa2006-11-13 16:02:22 -08003000 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001 }
3002 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003003
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004 if (!dev_valid_name(dev->name)) {
3005 ret = -EINVAL;
Adrian Bunk90833aa2006-11-13 16:02:22 -08003006 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007 }
3008
3009 dev->ifindex = dev_new_index();
3010 if (dev->iflink == -1)
3011 dev->iflink = dev->ifindex;
3012
3013 /* Check for existence of name */
3014 head = dev_name_hash(dev->name);
3015 hlist_for_each(p, head) {
3016 struct net_device *d
3017 = hlist_entry(p, struct net_device, name_hlist);
3018 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
3019 ret = -EEXIST;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003020 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003022 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023
3024 /* Fix illegal SG+CSUM combinations. */
3025 if ((dev->features & NETIF_F_SG) &&
Herbert Xu8648b302006-06-17 22:06:05 -07003026 !(dev->features & NETIF_F_ALL_CSUM)) {
Stephen Hemminger5a8da022006-07-07 16:54:05 -07003027 printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no checksum feature.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028 dev->name);
3029 dev->features &= ~NETIF_F_SG;
3030 }
3031
3032 /* TSO requires that SG is present as well. */
3033 if ((dev->features & NETIF_F_TSO) &&
3034 !(dev->features & NETIF_F_SG)) {
Stephen Hemminger5a8da022006-07-07 16:54:05 -07003035 printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no SG feature.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036 dev->name);
3037 dev->features &= ~NETIF_F_TSO;
3038 }
Ananda Rajue89e9cf2005-10-18 15:46:41 -07003039 if (dev->features & NETIF_F_UFO) {
3040 if (!(dev->features & NETIF_F_HW_CSUM)) {
3041 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3042 "NETIF_F_HW_CSUM feature.\n",
3043 dev->name);
3044 dev->features &= ~NETIF_F_UFO;
3045 }
3046 if (!(dev->features & NETIF_F_SG)) {
3047 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3048 "NETIF_F_SG feature.\n",
3049 dev->name);
3050 dev->features &= ~NETIF_F_UFO;
3051 }
3052 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003053
3054 /*
3055 * nil rebuild_header routine,
3056 * that should be never called and used as just bug trap.
3057 */
3058
3059 if (!dev->rebuild_header)
3060 dev->rebuild_header = default_rebuild_header;
3061
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003062 ret = netdev_register_sysfs(dev);
3063 if (ret)
Adrian Bunk90833aa2006-11-13 16:02:22 -08003064 goto out;
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003065 dev->reg_state = NETREG_REGISTERED;
3066
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067 /*
3068 * Default initial state at registry is that the
3069 * device is present.
3070 */
3071
3072 set_bit(__LINK_STATE_PRESENT, &dev->state);
3073
3074 dev->next = NULL;
3075 dev_init_scheduler(dev);
3076 write_lock_bh(&dev_base_lock);
3077 *dev_tail = dev;
3078 dev_tail = &dev->next;
3079 hlist_add_head(&dev->name_hlist, head);
3080 hlist_add_head(&dev->index_hlist, dev_index_hash(dev->ifindex));
3081 dev_hold(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003082 write_unlock_bh(&dev_base_lock);
3083
3084 /* Notify protocols, that a new device appeared. */
Alan Sternf07d5b92006-05-09 15:23:03 -07003085 raw_notifier_call_chain(&netdev_chain, NETDEV_REGISTER, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003086
Linus Torvalds1da177e2005-04-16 15:20:36 -07003087 ret = 0;
3088
3089out:
3090 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003091}
3092
3093/**
3094 * register_netdev - register a network device
3095 * @dev: device to register
3096 *
3097 * Take a completed network device structure and add it to the kernel
3098 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3099 * chain. 0 is returned on success. A negative errno code is returned
3100 * on a failure to set up the device, or if the name is a duplicate.
3101 *
Borislav Petkov38b4da32007-04-20 22:14:10 -07003102 * This is a wrapper around register_netdevice that takes the rtnl semaphore
Linus Torvalds1da177e2005-04-16 15:20:36 -07003103 * and expands the device name if you passed a format string to
3104 * alloc_netdev.
3105 */
3106int register_netdev(struct net_device *dev)
3107{
3108 int err;
3109
3110 rtnl_lock();
3111
3112 /*
3113 * If the name is a format string the caller wants us to do a
3114 * name allocation.
3115 */
3116 if (strchr(dev->name, '%')) {
3117 err = dev_alloc_name(dev, dev->name);
3118 if (err < 0)
3119 goto out;
3120 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003121
Linus Torvalds1da177e2005-04-16 15:20:36 -07003122 err = register_netdevice(dev);
3123out:
3124 rtnl_unlock();
3125 return err;
3126}
3127EXPORT_SYMBOL(register_netdev);
3128
3129/*
3130 * netdev_wait_allrefs - wait until all references are gone.
3131 *
3132 * This is called when unregistering network devices.
3133 *
3134 * Any protocol or device that holds a reference should register
3135 * for netdevice notification, and cleanup and put back the
3136 * reference if they receive an UNREGISTER event.
3137 * We can get stuck here if buggy protocols don't correctly
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003138 * call dev_put.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003139 */
3140static void netdev_wait_allrefs(struct net_device *dev)
3141{
3142 unsigned long rebroadcast_time, warning_time;
3143
3144 rebroadcast_time = warning_time = jiffies;
3145 while (atomic_read(&dev->refcnt) != 0) {
3146 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
Stephen Hemminger6756ae42006-03-20 22:23:58 -08003147 rtnl_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003148
3149 /* Rebroadcast unregister notification */
Alan Sternf07d5b92006-05-09 15:23:03 -07003150 raw_notifier_call_chain(&netdev_chain,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003151 NETDEV_UNREGISTER, dev);
3152
3153 if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
3154 &dev->state)) {
3155 /* We must not have linkwatch events
3156 * pending on unregister. If this
3157 * happens, we simply run the queue
3158 * unscheduled, resulting in a noop
3159 * for this device.
3160 */
3161 linkwatch_run_queue();
3162 }
3163
Stephen Hemminger6756ae42006-03-20 22:23:58 -08003164 __rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165
3166 rebroadcast_time = jiffies;
3167 }
3168
3169 msleep(250);
3170
3171 if (time_after(jiffies, warning_time + 10 * HZ)) {
3172 printk(KERN_EMERG "unregister_netdevice: "
3173 "waiting for %s to become free. Usage "
3174 "count = %d\n",
3175 dev->name, atomic_read(&dev->refcnt));
3176 warning_time = jiffies;
3177 }
3178 }
3179}
3180
3181/* The sequence is:
3182 *
3183 * rtnl_lock();
3184 * ...
3185 * register_netdevice(x1);
3186 * register_netdevice(x2);
3187 * ...
3188 * unregister_netdevice(y1);
3189 * unregister_netdevice(y2);
3190 * ...
3191 * rtnl_unlock();
3192 * free_netdev(y1);
3193 * free_netdev(y2);
3194 *
3195 * We are invoked by rtnl_unlock() after it drops the semaphore.
3196 * This allows us to deal with problems:
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003197 * 1) We can delete sysfs objects which invoke hotplug
Linus Torvalds1da177e2005-04-16 15:20:36 -07003198 * without deadlocking with linkwatch via keventd.
3199 * 2) Since we run with the RTNL semaphore not held, we can sleep
3200 * safely in order to wait for the netdev refcnt to drop to zero.
3201 */
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -08003202static DEFINE_MUTEX(net_todo_run_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003203void netdev_run_todo(void)
3204{
Oleg Nesterov626ab0e2006-06-23 02:05:55 -07003205 struct list_head list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206
3207 /* Need to guard against multiple cpu's getting out of order. */
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -08003208 mutex_lock(&net_todo_run_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003209
3210 /* Not safe to do outside the semaphore. We must not return
3211 * until all unregister events invoked by the local processor
3212 * have been completed (either by this todo run, or one on
3213 * another cpu).
3214 */
3215 if (list_empty(&net_todo_list))
3216 goto out;
3217
3218 /* Snapshot list, allow later requests */
3219 spin_lock(&net_todo_list_lock);
Oleg Nesterov626ab0e2006-06-23 02:05:55 -07003220 list_replace_init(&net_todo_list, &list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003221 spin_unlock(&net_todo_list_lock);
Oleg Nesterov626ab0e2006-06-23 02:05:55 -07003222
Linus Torvalds1da177e2005-04-16 15:20:36 -07003223 while (!list_empty(&list)) {
3224 struct net_device *dev
3225 = list_entry(list.next, struct net_device, todo_list);
3226 list_del(&dev->todo_list);
3227
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003228 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003229 printk(KERN_ERR "network todo '%s' but state %d\n",
3230 dev->name, dev->reg_state);
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003231 dump_stack();
3232 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003233 }
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003234
3235 netdev_unregister_sysfs(dev);
3236 dev->reg_state = NETREG_UNREGISTERED;
3237
3238 netdev_wait_allrefs(dev);
3239
3240 /* paranoia */
3241 BUG_ON(atomic_read(&dev->refcnt));
3242 BUG_TRAP(!dev->ip_ptr);
3243 BUG_TRAP(!dev->ip6_ptr);
3244 BUG_TRAP(!dev->dn_ptr);
3245
3246 /* It must be the very last action,
3247 * after this 'dev' may point to freed up memory.
3248 */
3249 if (dev->destructor)
3250 dev->destructor(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003251 }
3252
3253out:
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -08003254 mutex_unlock(&net_todo_run_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255}
3256
Rusty Russell5a1b5892007-04-28 21:04:03 -07003257static struct net_device_stats *internal_stats(struct net_device *dev)
Rusty Russellc45d2862007-03-28 14:29:08 -07003258{
Rusty Russell5a1b5892007-04-28 21:04:03 -07003259 return &dev->stats;
Rusty Russellc45d2862007-03-28 14:29:08 -07003260}
3261
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262/**
3263 * alloc_netdev - allocate network device
3264 * @sizeof_priv: size of private data to allocate space for
3265 * @name: device name format string
3266 * @setup: callback to initialize device
3267 *
3268 * Allocates a struct net_device with private data area for driver use
3269 * and performs basic initialization.
3270 */
3271struct net_device *alloc_netdev(int sizeof_priv, const char *name,
3272 void (*setup)(struct net_device *))
3273{
3274 void *p;
3275 struct net_device *dev;
3276 int alloc_size;
3277
Stephen Hemmingerb6fe17d2006-08-29 17:06:13 -07003278 BUG_ON(strlen(name) >= sizeof(dev->name));
3279
Linus Torvalds1da177e2005-04-16 15:20:36 -07003280 /* ensure 32-byte alignment of both the device and private area */
3281 alloc_size = (sizeof(*dev) + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
3282 alloc_size += sizeof_priv + NETDEV_ALIGN_CONST;
3283
Paolo 'Blaisorblade' Giarrusso31380de2006-04-06 22:38:28 -07003284 p = kzalloc(alloc_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003285 if (!p) {
Stephen Hemmingerb6fe17d2006-08-29 17:06:13 -07003286 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003287 return NULL;
3288 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289
3290 dev = (struct net_device *)
3291 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
3292 dev->padded = (char *)dev - (char *)p;
3293
3294 if (sizeof_priv)
3295 dev->priv = netdev_priv(dev);
3296
Rusty Russell5a1b5892007-04-28 21:04:03 -07003297 dev->get_stats = internal_stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003298 setup(dev);
3299 strcpy(dev->name, name);
3300 return dev;
3301}
3302EXPORT_SYMBOL(alloc_netdev);
3303
3304/**
3305 * free_netdev - free network device
3306 * @dev: device
3307 *
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003308 * This function does the last stage of destroying an allocated device
3309 * interface. The reference to the device object is released.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310 * If this is the last reference then it will be freed.
3311 */
3312void free_netdev(struct net_device *dev)
3313{
3314#ifdef CONFIG_SYSFS
Stephen Hemminger3041a062006-05-26 13:25:24 -07003315 /* Compatibility with error handling in drivers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003316 if (dev->reg_state == NETREG_UNINITIALIZED) {
3317 kfree((char *)dev - dev->padded);
3318 return;
3319 }
3320
3321 BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
3322 dev->reg_state = NETREG_RELEASED;
3323
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07003324 /* will free via device release */
3325 put_device(&dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003326#else
3327 kfree((char *)dev - dev->padded);
3328#endif
3329}
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003330
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331/* Synchronize with packet receive processing. */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003332void synchronize_net(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003333{
3334 might_sleep();
Paul E. McKenneyfbd568a3e2005-05-01 08:59:04 -07003335 synchronize_rcu();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003336}
3337
3338/**
3339 * unregister_netdevice - remove device from the kernel
3340 * @dev: device
3341 *
3342 * This function shuts down a device interface and removes it
3343 * from the kernel tables. On success 0 is returned, on a failure
3344 * a negative errno code is returned.
3345 *
3346 * Callers must hold the rtnl semaphore. You may want
3347 * unregister_netdev() instead of this.
3348 */
3349
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08003350void unregister_netdevice(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003351{
3352 struct net_device *d, **dp;
3353
3354 BUG_ON(dev_boot_phase);
3355 ASSERT_RTNL();
3356
3357 /* Some devices call without registering for initialization unwind. */
3358 if (dev->reg_state == NETREG_UNINITIALIZED) {
3359 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3360 "was registered\n", dev->name, dev);
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08003361
3362 WARN_ON(1);
3363 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003364 }
3365
3366 BUG_ON(dev->reg_state != NETREG_REGISTERED);
3367
3368 /* If device is running, close it first. */
3369 if (dev->flags & IFF_UP)
3370 dev_close(dev);
3371
3372 /* And unlink it from device chain. */
3373 for (dp = &dev_base; (d = *dp) != NULL; dp = &d->next) {
3374 if (d == dev) {
3375 write_lock_bh(&dev_base_lock);
3376 hlist_del(&dev->name_hlist);
3377 hlist_del(&dev->index_hlist);
3378 if (dev_tail == &dev->next)
3379 dev_tail = dp;
3380 *dp = d->next;
3381 write_unlock_bh(&dev_base_lock);
3382 break;
3383 }
3384 }
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08003385 BUG_ON(!d);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003386
3387 dev->reg_state = NETREG_UNREGISTERING;
3388
3389 synchronize_net();
3390
3391 /* Shutdown queueing discipline. */
3392 dev_shutdown(dev);
3393
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003394
Linus Torvalds1da177e2005-04-16 15:20:36 -07003395 /* Notify protocols, that we are about to destroy
3396 this device. They should clean all the things.
3397 */
Alan Sternf07d5b92006-05-09 15:23:03 -07003398 raw_notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003399
Linus Torvalds1da177e2005-04-16 15:20:36 -07003400 /*
3401 * Flush the multicast chain
3402 */
3403 dev_mc_discard(dev);
3404
3405 if (dev->uninit)
3406 dev->uninit(dev);
3407
3408 /* Notifier chain MUST detach us from master device. */
3409 BUG_TRAP(!dev->master);
3410
Linus Torvalds1da177e2005-04-16 15:20:36 -07003411 /* Finish processing unregister after unlock */
3412 net_set_todo(dev);
3413
3414 synchronize_net();
3415
3416 dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003417}
3418
3419/**
3420 * unregister_netdev - remove device from the kernel
3421 * @dev: device
3422 *
3423 * This function shuts down a device interface and removes it
3424 * from the kernel tables. On success 0 is returned, on a failure
3425 * a negative errno code is returned.
3426 *
3427 * This is just a wrapper for unregister_netdevice that takes
3428 * the rtnl semaphore. In general you want to use this and not
3429 * unregister_netdevice.
3430 */
3431void unregister_netdev(struct net_device *dev)
3432{
3433 rtnl_lock();
3434 unregister_netdevice(dev);
3435 rtnl_unlock();
3436}
3437
3438EXPORT_SYMBOL(unregister_netdev);
3439
Linus Torvalds1da177e2005-04-16 15:20:36 -07003440static int dev_cpu_callback(struct notifier_block *nfb,
3441 unsigned long action,
3442 void *ocpu)
3443{
3444 struct sk_buff **list_skb;
3445 struct net_device **list_net;
3446 struct sk_buff *skb;
3447 unsigned int cpu, oldcpu = (unsigned long)ocpu;
3448 struct softnet_data *sd, *oldsd;
3449
3450 if (action != CPU_DEAD)
3451 return NOTIFY_OK;
3452
3453 local_irq_disable();
3454 cpu = smp_processor_id();
3455 sd = &per_cpu(softnet_data, cpu);
3456 oldsd = &per_cpu(softnet_data, oldcpu);
3457
3458 /* Find end of our completion_queue. */
3459 list_skb = &sd->completion_queue;
3460 while (*list_skb)
3461 list_skb = &(*list_skb)->next;
3462 /* Append completion queue from offline CPU. */
3463 *list_skb = oldsd->completion_queue;
3464 oldsd->completion_queue = NULL;
3465
3466 /* Find end of our output_queue. */
3467 list_net = &sd->output_queue;
3468 while (*list_net)
3469 list_net = &(*list_net)->next_sched;
3470 /* Append output queue from offline CPU. */
3471 *list_net = oldsd->output_queue;
3472 oldsd->output_queue = NULL;
3473
3474 raise_softirq_irqoff(NET_TX_SOFTIRQ);
3475 local_irq_enable();
3476
3477 /* Process offline CPU's input_pkt_queue */
3478 while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
3479 netif_rx(skb);
3480
3481 return NOTIFY_OK;
3482}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003483
Chris Leechdb217332006-06-17 21:24:58 -07003484#ifdef CONFIG_NET_DMA
3485/**
3486 * net_dma_rebalance -
3487 * This is called when the number of channels allocated to the net_dma_client
3488 * changes. The net_dma_client tries to have one DMA channel per CPU.
3489 */
3490static void net_dma_rebalance(void)
3491{
3492 unsigned int cpu, i, n;
3493 struct dma_chan *chan;
3494
Chris Leechdb217332006-06-17 21:24:58 -07003495 if (net_dma_count == 0) {
3496 for_each_online_cpu(cpu)
Alexey Dobriyan29bbd722006-08-02 15:02:31 -07003497 rcu_assign_pointer(per_cpu(softnet_data, cpu).net_dma, NULL);
Chris Leechdb217332006-06-17 21:24:58 -07003498 return;
3499 }
3500
3501 i = 0;
3502 cpu = first_cpu(cpu_online_map);
3503
3504 rcu_read_lock();
3505 list_for_each_entry(chan, &net_dma_client->channels, client_node) {
3506 n = ((num_online_cpus() / net_dma_count)
3507 + (i < (num_online_cpus() % net_dma_count) ? 1 : 0));
3508
3509 while(n) {
Alexey Dobriyan29bbd722006-08-02 15:02:31 -07003510 per_cpu(softnet_data, cpu).net_dma = chan;
Chris Leechdb217332006-06-17 21:24:58 -07003511 cpu = next_cpu(cpu, cpu_online_map);
3512 n--;
3513 }
3514 i++;
3515 }
3516 rcu_read_unlock();
Chris Leechdb217332006-06-17 21:24:58 -07003517}
3518
3519/**
3520 * netdev_dma_event - event callback for the net_dma_client
3521 * @client: should always be net_dma_client
Randy Dunlapf4b8ea72006-06-22 16:00:11 -07003522 * @chan: DMA channel for the event
3523 * @event: event type
Chris Leechdb217332006-06-17 21:24:58 -07003524 */
3525static void netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
3526 enum dma_event event)
3527{
3528 spin_lock(&net_dma_event_lock);
3529 switch (event) {
3530 case DMA_RESOURCE_ADDED:
3531 net_dma_count++;
3532 net_dma_rebalance();
3533 break;
3534 case DMA_RESOURCE_REMOVED:
3535 net_dma_count--;
3536 net_dma_rebalance();
3537 break;
3538 default:
3539 break;
3540 }
3541 spin_unlock(&net_dma_event_lock);
3542}
3543
3544/**
3545 * netdev_dma_regiser - register the networking subsystem as a DMA client
3546 */
3547static int __init netdev_dma_register(void)
3548{
3549 spin_lock_init(&net_dma_event_lock);
3550 net_dma_client = dma_async_client_register(netdev_dma_event);
3551 if (net_dma_client == NULL)
3552 return -ENOMEM;
3553
3554 dma_async_client_chan_request(net_dma_client, num_online_cpus());
3555 return 0;
3556}
3557
3558#else
3559static int __init netdev_dma_register(void) { return -ENODEV; }
3560#endif /* CONFIG_NET_DMA */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003561
3562/*
3563 * Initialize the DEV module. At boot time this walks the device list and
3564 * unhooks any devices that fail to initialise (normally hardware not
3565 * present) and leaves us with a valid list of present and active devices.
3566 *
3567 */
3568
3569/*
3570 * This is called single threaded during boot, so no need
3571 * to take the rtnl semaphore.
3572 */
3573static int __init net_dev_init(void)
3574{
3575 int i, rc = -ENOMEM;
3576
3577 BUG_ON(!dev_boot_phase);
3578
Linus Torvalds1da177e2005-04-16 15:20:36 -07003579 if (dev_proc_init())
3580 goto out;
3581
3582 if (netdev_sysfs_init())
3583 goto out;
3584
3585 INIT_LIST_HEAD(&ptype_all);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003586 for (i = 0; i < 16; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003587 INIT_LIST_HEAD(&ptype_base[i]);
3588
3589 for (i = 0; i < ARRAY_SIZE(dev_name_head); i++)
3590 INIT_HLIST_HEAD(&dev_name_head[i]);
3591
3592 for (i = 0; i < ARRAY_SIZE(dev_index_head); i++)
3593 INIT_HLIST_HEAD(&dev_index_head[i]);
3594
3595 /*
3596 * Initialise the packet receive queues.
3597 */
3598
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -07003599 for_each_possible_cpu(i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003600 struct softnet_data *queue;
3601
3602 queue = &per_cpu(softnet_data, i);
3603 skb_queue_head_init(&queue->input_pkt_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003604 queue->completion_queue = NULL;
3605 INIT_LIST_HEAD(&queue->poll_list);
3606 set_bit(__LINK_STATE_START, &queue->backlog_dev.state);
3607 queue->backlog_dev.weight = weight_p;
3608 queue->backlog_dev.poll = process_backlog;
3609 atomic_set(&queue->backlog_dev.refcnt, 1);
3610 }
3611
Chris Leechdb217332006-06-17 21:24:58 -07003612 netdev_dma_register();
3613
Linus Torvalds1da177e2005-04-16 15:20:36 -07003614 dev_boot_phase = 0;
3615
3616 open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
3617 open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
3618
3619 hotcpu_notifier(dev_cpu_callback, 0);
3620 dst_init();
3621 dev_mcast_init();
3622 rc = 0;
3623out:
3624 return rc;
3625}
3626
3627subsys_initcall(net_dev_init);
3628
3629EXPORT_SYMBOL(__dev_get_by_index);
3630EXPORT_SYMBOL(__dev_get_by_name);
3631EXPORT_SYMBOL(__dev_remove_pack);
Mitch Williamsc2373ee2005-11-09 10:34:45 -08003632EXPORT_SYMBOL(dev_valid_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003633EXPORT_SYMBOL(dev_add_pack);
3634EXPORT_SYMBOL(dev_alloc_name);
3635EXPORT_SYMBOL(dev_close);
3636EXPORT_SYMBOL(dev_get_by_flags);
3637EXPORT_SYMBOL(dev_get_by_index);
3638EXPORT_SYMBOL(dev_get_by_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003639EXPORT_SYMBOL(dev_open);
3640EXPORT_SYMBOL(dev_queue_xmit);
3641EXPORT_SYMBOL(dev_remove_pack);
3642EXPORT_SYMBOL(dev_set_allmulti);
3643EXPORT_SYMBOL(dev_set_promiscuity);
3644EXPORT_SYMBOL(dev_change_flags);
3645EXPORT_SYMBOL(dev_set_mtu);
3646EXPORT_SYMBOL(dev_set_mac_address);
3647EXPORT_SYMBOL(free_netdev);
3648EXPORT_SYMBOL(netdev_boot_setup_check);
3649EXPORT_SYMBOL(netdev_set_master);
3650EXPORT_SYMBOL(netdev_state_change);
3651EXPORT_SYMBOL(netif_receive_skb);
3652EXPORT_SYMBOL(netif_rx);
3653EXPORT_SYMBOL(register_gifconf);
3654EXPORT_SYMBOL(register_netdevice);
3655EXPORT_SYMBOL(register_netdevice_notifier);
3656EXPORT_SYMBOL(skb_checksum_help);
3657EXPORT_SYMBOL(synchronize_net);
3658EXPORT_SYMBOL(unregister_netdevice);
3659EXPORT_SYMBOL(unregister_netdevice_notifier);
3660EXPORT_SYMBOL(net_enable_timestamp);
3661EXPORT_SYMBOL(net_disable_timestamp);
3662EXPORT_SYMBOL(dev_get_flags);
3663
3664#if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
3665EXPORT_SYMBOL(br_handle_frame_hook);
3666EXPORT_SYMBOL(br_fdb_get_hook);
3667EXPORT_SYMBOL(br_fdb_put_hook);
3668#endif
3669
3670#ifdef CONFIG_KMOD
3671EXPORT_SYMBOL(dev_load);
3672#endif
3673
3674EXPORT_PER_CPU_SYMBOL(softnet_data);