blob: f3b99701da5bef2adeec42e475ea26bcc85c4722 [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>
Adrian Bunkd86b5e02006-01-21 00:46:55 +0100112#include <linux/wireless.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
Patrick McHardy84fa7932006-08-29 16:44:56 -07001205 if (unlikely(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 Russellc45d2862007-03-28 14:29:08 -07002104 if (stats) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2106 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2107 dev->name, stats->rx_bytes, stats->rx_packets,
2108 stats->rx_errors,
2109 stats->rx_dropped + stats->rx_missed_errors,
2110 stats->rx_fifo_errors,
2111 stats->rx_length_errors + stats->rx_over_errors +
2112 stats->rx_crc_errors + stats->rx_frame_errors,
2113 stats->rx_compressed, stats->multicast,
2114 stats->tx_bytes, stats->tx_packets,
2115 stats->tx_errors, stats->tx_dropped,
2116 stats->tx_fifo_errors, stats->collisions,
2117 stats->tx_carrier_errors +
2118 stats->tx_aborted_errors +
2119 stats->tx_window_errors +
2120 stats->tx_heartbeat_errors,
2121 stats->tx_compressed);
2122 } else
2123 seq_printf(seq, "%6s: No statistics available.\n", dev->name);
2124}
2125
2126/*
2127 * Called from the PROCfs module. This now uses the new arbitrary sized
2128 * /proc/net interface to create /proc/net/dev
2129 */
2130static int dev_seq_show(struct seq_file *seq, void *v)
2131{
2132 if (v == SEQ_START_TOKEN)
2133 seq_puts(seq, "Inter-| Receive "
2134 " | Transmit\n"
2135 " face |bytes packets errs drop fifo frame "
2136 "compressed multicast|bytes packets errs "
2137 "drop fifo colls carrier compressed\n");
2138 else
2139 dev_seq_printf_stats(seq, v);
2140 return 0;
2141}
2142
2143static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2144{
2145 struct netif_rx_stats *rc = NULL;
2146
2147 while (*pos < NR_CPUS)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002148 if (cpu_online(*pos)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 rc = &per_cpu(netdev_rx_stat, *pos);
2150 break;
2151 } else
2152 ++*pos;
2153 return rc;
2154}
2155
2156static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2157{
2158 return softnet_get_online(pos);
2159}
2160
2161static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2162{
2163 ++*pos;
2164 return softnet_get_online(pos);
2165}
2166
2167static void softnet_seq_stop(struct seq_file *seq, void *v)
2168{
2169}
2170
2171static int softnet_seq_show(struct seq_file *seq, void *v)
2172{
2173 struct netif_rx_stats *s = v;
2174
2175 seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
Stephen Hemminger31aa02c2005-06-23 20:12:48 -07002176 s->total, s->dropped, s->time_squeeze, 0,
Stephen Hemmingerc1ebcdb2005-06-23 20:08:59 -07002177 0, 0, 0, 0, /* was fastroute */
2178 s->cpu_collision );
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 return 0;
2180}
2181
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002182static const struct seq_operations dev_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 .start = dev_seq_start,
2184 .next = dev_seq_next,
2185 .stop = dev_seq_stop,
2186 .show = dev_seq_show,
2187};
2188
2189static int dev_seq_open(struct inode *inode, struct file *file)
2190{
2191 return seq_open(file, &dev_seq_ops);
2192}
2193
Arjan van de Ven9a321442007-02-12 00:55:35 -08002194static const struct file_operations dev_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 .owner = THIS_MODULE,
2196 .open = dev_seq_open,
2197 .read = seq_read,
2198 .llseek = seq_lseek,
2199 .release = seq_release,
2200};
2201
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002202static const struct seq_operations softnet_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203 .start = softnet_seq_start,
2204 .next = softnet_seq_next,
2205 .stop = softnet_seq_stop,
2206 .show = softnet_seq_show,
2207};
2208
2209static int softnet_seq_open(struct inode *inode, struct file *file)
2210{
2211 return seq_open(file, &softnet_seq_ops);
2212}
2213
Arjan van de Ven9a321442007-02-12 00:55:35 -08002214static const struct file_operations softnet_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215 .owner = THIS_MODULE,
2216 .open = softnet_seq_open,
2217 .read = seq_read,
2218 .llseek = seq_lseek,
2219 .release = seq_release,
2220};
2221
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002222static void *ptype_get_idx(loff_t pos)
2223{
2224 struct packet_type *pt = NULL;
2225 loff_t i = 0;
2226 int t;
2227
2228 list_for_each_entry_rcu(pt, &ptype_all, list) {
2229 if (i == pos)
2230 return pt;
2231 ++i;
2232 }
2233
2234 for (t = 0; t < 16; t++) {
2235 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
2236 if (i == pos)
2237 return pt;
2238 ++i;
2239 }
2240 }
2241 return NULL;
2242}
2243
2244static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
2245{
2246 rcu_read_lock();
2247 return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
2248}
2249
2250static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2251{
2252 struct packet_type *pt;
2253 struct list_head *nxt;
2254 int hash;
2255
2256 ++*pos;
2257 if (v == SEQ_START_TOKEN)
2258 return ptype_get_idx(0);
2259
2260 pt = v;
2261 nxt = pt->list.next;
2262 if (pt->type == htons(ETH_P_ALL)) {
2263 if (nxt != &ptype_all)
2264 goto found;
2265 hash = 0;
2266 nxt = ptype_base[0].next;
2267 } else
2268 hash = ntohs(pt->type) & 15;
2269
2270 while (nxt == &ptype_base[hash]) {
2271 if (++hash >= 16)
2272 return NULL;
2273 nxt = ptype_base[hash].next;
2274 }
2275found:
2276 return list_entry(nxt, struct packet_type, list);
2277}
2278
2279static void ptype_seq_stop(struct seq_file *seq, void *v)
2280{
2281 rcu_read_unlock();
2282}
2283
2284static void ptype_seq_decode(struct seq_file *seq, void *sym)
2285{
2286#ifdef CONFIG_KALLSYMS
2287 unsigned long offset = 0, symsize;
2288 const char *symname;
2289 char *modname;
2290 char namebuf[128];
2291
2292 symname = kallsyms_lookup((unsigned long)sym, &symsize, &offset,
2293 &modname, namebuf);
2294
2295 if (symname) {
2296 char *delim = ":";
2297
2298 if (!modname)
2299 modname = delim = "";
2300 seq_printf(seq, "%s%s%s%s+0x%lx", delim, modname, delim,
2301 symname, offset);
2302 return;
2303 }
2304#endif
2305
2306 seq_printf(seq, "[%p]", sym);
2307}
2308
2309static int ptype_seq_show(struct seq_file *seq, void *v)
2310{
2311 struct packet_type *pt = v;
2312
2313 if (v == SEQ_START_TOKEN)
2314 seq_puts(seq, "Type Device Function\n");
2315 else {
2316 if (pt->type == htons(ETH_P_ALL))
2317 seq_puts(seq, "ALL ");
2318 else
2319 seq_printf(seq, "%04x", ntohs(pt->type));
2320
2321 seq_printf(seq, " %-8s ",
2322 pt->dev ? pt->dev->name : "");
2323 ptype_seq_decode(seq, pt->func);
2324 seq_putc(seq, '\n');
2325 }
2326
2327 return 0;
2328}
2329
2330static const struct seq_operations ptype_seq_ops = {
2331 .start = ptype_seq_start,
2332 .next = ptype_seq_next,
2333 .stop = ptype_seq_stop,
2334 .show = ptype_seq_show,
2335};
2336
2337static int ptype_seq_open(struct inode *inode, struct file *file)
2338{
2339 return seq_open(file, &ptype_seq_ops);
2340}
2341
2342static const struct file_operations ptype_seq_fops = {
2343 .owner = THIS_MODULE,
2344 .open = ptype_seq_open,
2345 .read = seq_read,
2346 .llseek = seq_lseek,
2347 .release = seq_release,
2348};
2349
2350
Adrian Bunkd86b5e02006-01-21 00:46:55 +01002351#ifdef CONFIG_WIRELESS_EXT
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352extern int wireless_proc_init(void);
2353#else
2354#define wireless_proc_init() 0
2355#endif
2356
2357static int __init dev_proc_init(void)
2358{
2359 int rc = -ENOMEM;
2360
2361 if (!proc_net_fops_create("dev", S_IRUGO, &dev_seq_fops))
2362 goto out;
2363 if (!proc_net_fops_create("softnet_stat", S_IRUGO, &softnet_seq_fops))
2364 goto out_dev;
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002365 if (!proc_net_fops_create("ptype", S_IRUGO, &ptype_seq_fops))
2366 goto out_dev2;
2367
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368 if (wireless_proc_init())
2369 goto out_softnet;
2370 rc = 0;
2371out:
2372 return rc;
2373out_softnet:
2374 proc_net_remove("softnet_stat");
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002375out_dev2:
2376 proc_net_remove("ptype");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377out_dev:
2378 proc_net_remove("dev");
2379 goto out;
2380}
2381#else
2382#define dev_proc_init() 0
2383#endif /* CONFIG_PROC_FS */
2384
2385
2386/**
2387 * netdev_set_master - set up master/slave pair
2388 * @slave: slave device
2389 * @master: new master device
2390 *
2391 * Changes the master device of the slave. Pass %NULL to break the
2392 * bonding. The caller must hold the RTNL semaphore. On a failure
2393 * a negative errno code is returned. On success the reference counts
2394 * are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2395 * function returns zero.
2396 */
2397int netdev_set_master(struct net_device *slave, struct net_device *master)
2398{
2399 struct net_device *old = slave->master;
2400
2401 ASSERT_RTNL();
2402
2403 if (master) {
2404 if (old)
2405 return -EBUSY;
2406 dev_hold(master);
2407 }
2408
2409 slave->master = master;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002410
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411 synchronize_net();
2412
2413 if (old)
2414 dev_put(old);
2415
2416 if (master)
2417 slave->flags |= IFF_SLAVE;
2418 else
2419 slave->flags &= ~IFF_SLAVE;
2420
2421 rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2422 return 0;
2423}
2424
2425/**
2426 * dev_set_promiscuity - update promiscuity count on a device
2427 * @dev: device
2428 * @inc: modifier
2429 *
Stephen Hemminger3041a062006-05-26 13:25:24 -07002430 * Add or remove promiscuity from a device. While the count in the device
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 * remains above zero the interface remains promiscuous. Once it hits zero
2432 * the device reverts back to normal filtering operation. A negative inc
2433 * value is used to drop promiscuity on the device.
2434 */
2435void dev_set_promiscuity(struct net_device *dev, int inc)
2436{
2437 unsigned short old_flags = dev->flags;
2438
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439 if ((dev->promiscuity += inc) == 0)
2440 dev->flags &= ~IFF_PROMISC;
David Chau52609c02005-07-05 15:11:06 -07002441 else
2442 dev->flags |= IFF_PROMISC;
2443 if (dev->flags != old_flags) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444 dev_mc_upload(dev);
2445 printk(KERN_INFO "device %s %s promiscuous mode\n",
2446 dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002447 "left");
Steve Grubb5bdb9882005-12-03 08:39:35 -05002448 audit_log(current->audit_context, GFP_ATOMIC,
2449 AUDIT_ANOM_PROMISCUOUS,
2450 "dev=%s prom=%d old_prom=%d auid=%u",
2451 dev->name, (dev->flags & IFF_PROMISC),
2452 (old_flags & IFF_PROMISC),
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002453 audit_get_loginuid(current->audit_context));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454 }
2455}
2456
2457/**
2458 * dev_set_allmulti - update allmulti count on a device
2459 * @dev: device
2460 * @inc: modifier
2461 *
2462 * Add or remove reception of all multicast frames to a device. While the
2463 * count in the device remains above zero the interface remains listening
2464 * to all interfaces. Once it hits zero the device reverts back to normal
2465 * filtering operation. A negative @inc value is used to drop the counter
2466 * when releasing a resource needing all multicasts.
2467 */
2468
2469void dev_set_allmulti(struct net_device *dev, int inc)
2470{
2471 unsigned short old_flags = dev->flags;
2472
2473 dev->flags |= IFF_ALLMULTI;
2474 if ((dev->allmulti += inc) == 0)
2475 dev->flags &= ~IFF_ALLMULTI;
2476 if (dev->flags ^ old_flags)
2477 dev_mc_upload(dev);
2478}
2479
2480unsigned dev_get_flags(const struct net_device *dev)
2481{
2482 unsigned flags;
2483
2484 flags = (dev->flags & ~(IFF_PROMISC |
2485 IFF_ALLMULTI |
Stefan Rompfb00055a2006-03-20 17:09:11 -08002486 IFF_RUNNING |
2487 IFF_LOWER_UP |
2488 IFF_DORMANT)) |
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 (dev->gflags & (IFF_PROMISC |
2490 IFF_ALLMULTI));
2491
Stefan Rompfb00055a2006-03-20 17:09:11 -08002492 if (netif_running(dev)) {
2493 if (netif_oper_up(dev))
2494 flags |= IFF_RUNNING;
2495 if (netif_carrier_ok(dev))
2496 flags |= IFF_LOWER_UP;
2497 if (netif_dormant(dev))
2498 flags |= IFF_DORMANT;
2499 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500
2501 return flags;
2502}
2503
2504int dev_change_flags(struct net_device *dev, unsigned flags)
2505{
2506 int ret;
2507 int old_flags = dev->flags;
2508
2509 /*
2510 * Set the flags on our device.
2511 */
2512
2513 dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
2514 IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
2515 IFF_AUTOMEDIA)) |
2516 (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
2517 IFF_ALLMULTI));
2518
2519 /*
2520 * Load in the correct multicast list now the flags have changed.
2521 */
2522
2523 dev_mc_upload(dev);
2524
2525 /*
2526 * Have we downed the interface. We handle IFF_UP ourselves
2527 * according to user attempts to set it, rather than blindly
2528 * setting it.
2529 */
2530
2531 ret = 0;
2532 if ((old_flags ^ flags) & IFF_UP) { /* Bit is different ? */
2533 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
2534
2535 if (!ret)
2536 dev_mc_upload(dev);
2537 }
2538
2539 if (dev->flags & IFF_UP &&
2540 ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
2541 IFF_VOLATILE)))
Alan Sternf07d5b92006-05-09 15:23:03 -07002542 raw_notifier_call_chain(&netdev_chain,
Alan Sterne041c682006-03-27 01:16:30 -08002543 NETDEV_CHANGE, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544
2545 if ((flags ^ dev->gflags) & IFF_PROMISC) {
2546 int inc = (flags & IFF_PROMISC) ? +1 : -1;
2547 dev->gflags ^= IFF_PROMISC;
2548 dev_set_promiscuity(dev, inc);
2549 }
2550
2551 /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
2552 is important. Some (broken) drivers set IFF_PROMISC, when
2553 IFF_ALLMULTI is requested not asking us and not reporting.
2554 */
2555 if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
2556 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
2557 dev->gflags ^= IFF_ALLMULTI;
2558 dev_set_allmulti(dev, inc);
2559 }
2560
2561 if (old_flags ^ dev->flags)
2562 rtmsg_ifinfo(RTM_NEWLINK, dev, old_flags ^ dev->flags);
2563
2564 return ret;
2565}
2566
2567int dev_set_mtu(struct net_device *dev, int new_mtu)
2568{
2569 int err;
2570
2571 if (new_mtu == dev->mtu)
2572 return 0;
2573
2574 /* MTU must be positive. */
2575 if (new_mtu < 0)
2576 return -EINVAL;
2577
2578 if (!netif_device_present(dev))
2579 return -ENODEV;
2580
2581 err = 0;
2582 if (dev->change_mtu)
2583 err = dev->change_mtu(dev, new_mtu);
2584 else
2585 dev->mtu = new_mtu;
2586 if (!err && dev->flags & IFF_UP)
Alan Sternf07d5b92006-05-09 15:23:03 -07002587 raw_notifier_call_chain(&netdev_chain,
Alan Sterne041c682006-03-27 01:16:30 -08002588 NETDEV_CHANGEMTU, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589 return err;
2590}
2591
2592int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
2593{
2594 int err;
2595
2596 if (!dev->set_mac_address)
2597 return -EOPNOTSUPP;
2598 if (sa->sa_family != dev->type)
2599 return -EINVAL;
2600 if (!netif_device_present(dev))
2601 return -ENODEV;
2602 err = dev->set_mac_address(dev, sa);
2603 if (!err)
Alan Sternf07d5b92006-05-09 15:23:03 -07002604 raw_notifier_call_chain(&netdev_chain,
Alan Sterne041c682006-03-27 01:16:30 -08002605 NETDEV_CHANGEADDR, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606 return err;
2607}
2608
2609/*
2610 * Perform the SIOCxIFxxx calls.
2611 */
2612static int dev_ifsioc(struct ifreq *ifr, unsigned int cmd)
2613{
2614 int err;
2615 struct net_device *dev = __dev_get_by_name(ifr->ifr_name);
2616
2617 if (!dev)
2618 return -ENODEV;
2619
2620 switch (cmd) {
2621 case SIOCGIFFLAGS: /* Get interface flags */
2622 ifr->ifr_flags = dev_get_flags(dev);
2623 return 0;
2624
2625 case SIOCSIFFLAGS: /* Set interface flags */
2626 return dev_change_flags(dev, ifr->ifr_flags);
2627
2628 case SIOCGIFMETRIC: /* Get the metric on the interface
2629 (currently unused) */
2630 ifr->ifr_metric = 0;
2631 return 0;
2632
2633 case SIOCSIFMETRIC: /* Set the metric on the interface
2634 (currently unused) */
2635 return -EOPNOTSUPP;
2636
2637 case SIOCGIFMTU: /* Get the MTU of a device */
2638 ifr->ifr_mtu = dev->mtu;
2639 return 0;
2640
2641 case SIOCSIFMTU: /* Set the MTU of a device */
2642 return dev_set_mtu(dev, ifr->ifr_mtu);
2643
2644 case SIOCGIFHWADDR:
2645 if (!dev->addr_len)
2646 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
2647 else
2648 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
2649 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
2650 ifr->ifr_hwaddr.sa_family = dev->type;
2651 return 0;
2652
2653 case SIOCSIFHWADDR:
2654 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
2655
2656 case SIOCSIFHWBROADCAST:
2657 if (ifr->ifr_hwaddr.sa_family != dev->type)
2658 return -EINVAL;
2659 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
2660 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
Alan Sternf07d5b92006-05-09 15:23:03 -07002661 raw_notifier_call_chain(&netdev_chain,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002662 NETDEV_CHANGEADDR, dev);
2663 return 0;
2664
2665 case SIOCGIFMAP:
2666 ifr->ifr_map.mem_start = dev->mem_start;
2667 ifr->ifr_map.mem_end = dev->mem_end;
2668 ifr->ifr_map.base_addr = dev->base_addr;
2669 ifr->ifr_map.irq = dev->irq;
2670 ifr->ifr_map.dma = dev->dma;
2671 ifr->ifr_map.port = dev->if_port;
2672 return 0;
2673
2674 case SIOCSIFMAP:
2675 if (dev->set_config) {
2676 if (!netif_device_present(dev))
2677 return -ENODEV;
2678 return dev->set_config(dev, &ifr->ifr_map);
2679 }
2680 return -EOPNOTSUPP;
2681
2682 case SIOCADDMULTI:
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_add(dev, ifr->ifr_hwaddr.sa_data,
2689 dev->addr_len, 1);
2690
2691 case SIOCDELMULTI:
2692 if (!dev->set_multicast_list ||
2693 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
2694 return -EINVAL;
2695 if (!netif_device_present(dev))
2696 return -ENODEV;
2697 return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
2698 dev->addr_len, 1);
2699
2700 case SIOCGIFINDEX:
2701 ifr->ifr_ifindex = dev->ifindex;
2702 return 0;
2703
2704 case SIOCGIFTXQLEN:
2705 ifr->ifr_qlen = dev->tx_queue_len;
2706 return 0;
2707
2708 case SIOCSIFTXQLEN:
2709 if (ifr->ifr_qlen < 0)
2710 return -EINVAL;
2711 dev->tx_queue_len = ifr->ifr_qlen;
2712 return 0;
2713
2714 case SIOCSIFNAME:
2715 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
2716 return dev_change_name(dev, ifr->ifr_newname);
2717
2718 /*
2719 * Unknown or private ioctl
2720 */
2721
2722 default:
2723 if ((cmd >= SIOCDEVPRIVATE &&
2724 cmd <= SIOCDEVPRIVATE + 15) ||
2725 cmd == SIOCBONDENSLAVE ||
2726 cmd == SIOCBONDRELEASE ||
2727 cmd == SIOCBONDSETHWADDR ||
2728 cmd == SIOCBONDSLAVEINFOQUERY ||
2729 cmd == SIOCBONDINFOQUERY ||
2730 cmd == SIOCBONDCHANGEACTIVE ||
2731 cmd == SIOCGMIIPHY ||
2732 cmd == SIOCGMIIREG ||
2733 cmd == SIOCSMIIREG ||
2734 cmd == SIOCBRADDIF ||
2735 cmd == SIOCBRDELIF ||
2736 cmd == SIOCWANDEV) {
2737 err = -EOPNOTSUPP;
2738 if (dev->do_ioctl) {
2739 if (netif_device_present(dev))
2740 err = dev->do_ioctl(dev, ifr,
2741 cmd);
2742 else
2743 err = -ENODEV;
2744 }
2745 } else
2746 err = -EINVAL;
2747
2748 }
2749 return err;
2750}
2751
2752/*
2753 * This function handles all "interface"-type I/O control requests. The actual
2754 * 'doing' part of this is dev_ifsioc above.
2755 */
2756
2757/**
2758 * dev_ioctl - network device ioctl
2759 * @cmd: command to issue
2760 * @arg: pointer to a struct ifreq in user space
2761 *
2762 * Issue ioctl functions to devices. This is normally called by the
2763 * user space syscall interfaces but can sometimes be useful for
2764 * other purposes. The return value is the return from the syscall if
2765 * positive or a negative errno code on error.
2766 */
2767
2768int dev_ioctl(unsigned int cmd, void __user *arg)
2769{
2770 struct ifreq ifr;
2771 int ret;
2772 char *colon;
2773
2774 /* One special case: SIOCGIFCONF takes ifconf argument
2775 and requires shared lock, because it sleeps writing
2776 to user space.
2777 */
2778
2779 if (cmd == SIOCGIFCONF) {
Stephen Hemminger6756ae42006-03-20 22:23:58 -08002780 rtnl_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781 ret = dev_ifconf((char __user *) arg);
Stephen Hemminger6756ae42006-03-20 22:23:58 -08002782 rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783 return ret;
2784 }
2785 if (cmd == SIOCGIFNAME)
2786 return dev_ifname((struct ifreq __user *)arg);
2787
2788 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2789 return -EFAULT;
2790
2791 ifr.ifr_name[IFNAMSIZ-1] = 0;
2792
2793 colon = strchr(ifr.ifr_name, ':');
2794 if (colon)
2795 *colon = 0;
2796
2797 /*
2798 * See which interface the caller is talking about.
2799 */
2800
2801 switch (cmd) {
2802 /*
2803 * These ioctl calls:
2804 * - can be done by all.
2805 * - atomic and do not require locking.
2806 * - return a value
2807 */
2808 case SIOCGIFFLAGS:
2809 case SIOCGIFMETRIC:
2810 case SIOCGIFMTU:
2811 case SIOCGIFHWADDR:
2812 case SIOCGIFSLAVE:
2813 case SIOCGIFMAP:
2814 case SIOCGIFINDEX:
2815 case SIOCGIFTXQLEN:
2816 dev_load(ifr.ifr_name);
2817 read_lock(&dev_base_lock);
2818 ret = dev_ifsioc(&ifr, cmd);
2819 read_unlock(&dev_base_lock);
2820 if (!ret) {
2821 if (colon)
2822 *colon = ':';
2823 if (copy_to_user(arg, &ifr,
2824 sizeof(struct ifreq)))
2825 ret = -EFAULT;
2826 }
2827 return ret;
2828
2829 case SIOCETHTOOL:
2830 dev_load(ifr.ifr_name);
2831 rtnl_lock();
2832 ret = dev_ethtool(&ifr);
2833 rtnl_unlock();
2834 if (!ret) {
2835 if (colon)
2836 *colon = ':';
2837 if (copy_to_user(arg, &ifr,
2838 sizeof(struct ifreq)))
2839 ret = -EFAULT;
2840 }
2841 return ret;
2842
2843 /*
2844 * These ioctl calls:
2845 * - require superuser power.
2846 * - require strict serialization.
2847 * - return a value
2848 */
2849 case SIOCGMIIPHY:
2850 case SIOCGMIIREG:
2851 case SIOCSIFNAME:
2852 if (!capable(CAP_NET_ADMIN))
2853 return -EPERM;
2854 dev_load(ifr.ifr_name);
2855 rtnl_lock();
2856 ret = dev_ifsioc(&ifr, cmd);
2857 rtnl_unlock();
2858 if (!ret) {
2859 if (colon)
2860 *colon = ':';
2861 if (copy_to_user(arg, &ifr,
2862 sizeof(struct ifreq)))
2863 ret = -EFAULT;
2864 }
2865 return ret;
2866
2867 /*
2868 * These ioctl calls:
2869 * - require superuser power.
2870 * - require strict serialization.
2871 * - do not return a value
2872 */
2873 case SIOCSIFFLAGS:
2874 case SIOCSIFMETRIC:
2875 case SIOCSIFMTU:
2876 case SIOCSIFMAP:
2877 case SIOCSIFHWADDR:
2878 case SIOCSIFSLAVE:
2879 case SIOCADDMULTI:
2880 case SIOCDELMULTI:
2881 case SIOCSIFHWBROADCAST:
2882 case SIOCSIFTXQLEN:
2883 case SIOCSMIIREG:
2884 case SIOCBONDENSLAVE:
2885 case SIOCBONDRELEASE:
2886 case SIOCBONDSETHWADDR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 case SIOCBONDCHANGEACTIVE:
2888 case SIOCBRADDIF:
2889 case SIOCBRDELIF:
2890 if (!capable(CAP_NET_ADMIN))
2891 return -EPERM;
Thomas Grafcabcac02006-01-24 12:46:33 -08002892 /* fall through */
2893 case SIOCBONDSLAVEINFOQUERY:
2894 case SIOCBONDINFOQUERY:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895 dev_load(ifr.ifr_name);
2896 rtnl_lock();
2897 ret = dev_ifsioc(&ifr, cmd);
2898 rtnl_unlock();
2899 return ret;
2900
2901 case SIOCGIFMEM:
2902 /* Get the per device memory space. We can add this but
2903 * currently do not support it */
2904 case SIOCSIFMEM:
2905 /* Set the per device memory buffer space.
2906 * Not applicable in our case */
2907 case SIOCSIFLINK:
2908 return -EINVAL;
2909
2910 /*
2911 * Unknown or private ioctl.
2912 */
2913 default:
2914 if (cmd == SIOCWANDEV ||
2915 (cmd >= SIOCDEVPRIVATE &&
2916 cmd <= SIOCDEVPRIVATE + 15)) {
2917 dev_load(ifr.ifr_name);
2918 rtnl_lock();
2919 ret = dev_ifsioc(&ifr, cmd);
2920 rtnl_unlock();
2921 if (!ret && copy_to_user(arg, &ifr,
2922 sizeof(struct ifreq)))
2923 ret = -EFAULT;
2924 return ret;
2925 }
Adrian Bunkd86b5e02006-01-21 00:46:55 +01002926#ifdef CONFIG_WIRELESS_EXT
Linus Torvalds1da177e2005-04-16 15:20:36 -07002927 /* Take care of Wireless Extensions */
2928 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
2929 /* If command is `set a parameter', or
2930 * `get the encoding parameters', check if
2931 * the user has the right to do it */
Jean Tourrilhesa4170162006-04-04 15:53:43 -07002932 if (IW_IS_SET(cmd) || cmd == SIOCGIWENCODE
2933 || cmd == SIOCGIWENCODEEXT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002934 if (!capable(CAP_NET_ADMIN))
2935 return -EPERM;
2936 }
2937 dev_load(ifr.ifr_name);
2938 rtnl_lock();
2939 /* Follow me in net/core/wireless.c */
2940 ret = wireless_process_ioctl(&ifr, cmd);
2941 rtnl_unlock();
2942 if (IW_IS_GET(cmd) &&
2943 copy_to_user(arg, &ifr,
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002944 sizeof(struct ifreq)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945 ret = -EFAULT;
2946 return ret;
2947 }
Adrian Bunkd86b5e02006-01-21 00:46:55 +01002948#endif /* CONFIG_WIRELESS_EXT */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 return -EINVAL;
2950 }
2951}
2952
2953
2954/**
2955 * dev_new_index - allocate an ifindex
2956 *
2957 * Returns a suitable unique value for a new device interface
2958 * number. The caller must hold the rtnl semaphore or the
2959 * dev_base_lock to be sure it remains unique.
2960 */
2961static int dev_new_index(void)
2962{
2963 static int ifindex;
2964 for (;;) {
2965 if (++ifindex <= 0)
2966 ifindex = 1;
2967 if (!__dev_get_by_index(ifindex))
2968 return ifindex;
2969 }
2970}
2971
2972static int dev_boot_phase = 1;
2973
2974/* Delayed registration/unregisteration */
2975static DEFINE_SPINLOCK(net_todo_list_lock);
2976static struct list_head net_todo_list = LIST_HEAD_INIT(net_todo_list);
2977
Stephen Hemminger6f05f622007-03-08 20:46:03 -08002978static void net_set_todo(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979{
2980 spin_lock(&net_todo_list_lock);
2981 list_add_tail(&dev->todo_list, &net_todo_list);
2982 spin_unlock(&net_todo_list_lock);
2983}
2984
2985/**
2986 * register_netdevice - register a network device
2987 * @dev: device to register
2988 *
2989 * Take a completed network device structure and add it to the kernel
2990 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
2991 * chain. 0 is returned on success. A negative errno code is returned
2992 * on a failure to set up the device, or if the name is a duplicate.
2993 *
2994 * Callers must hold the rtnl semaphore. You may want
2995 * register_netdev() instead of this.
2996 *
2997 * BUGS:
2998 * The locking appears insufficient to guarantee two parallel registers
2999 * will not get the same name.
3000 */
3001
3002int register_netdevice(struct net_device *dev)
3003{
3004 struct hlist_head *head;
3005 struct hlist_node *p;
3006 int ret;
3007
3008 BUG_ON(dev_boot_phase);
3009 ASSERT_RTNL();
3010
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003011 might_sleep();
3012
Linus Torvalds1da177e2005-04-16 15:20:36 -07003013 /* When net_device's are persistent, this will be fatal. */
3014 BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
3015
3016 spin_lock_init(&dev->queue_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07003017 spin_lock_init(&dev->_xmit_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003018 dev->xmit_lock_owner = -1;
3019#ifdef CONFIG_NET_CLS_ACT
3020 spin_lock_init(&dev->ingress_lock);
3021#endif
3022
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023 dev->iflink = -1;
3024
3025 /* Init, if this function is available */
3026 if (dev->init) {
3027 ret = dev->init(dev);
3028 if (ret) {
3029 if (ret > 0)
3030 ret = -EIO;
Adrian Bunk90833aa2006-11-13 16:02:22 -08003031 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 }
3033 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003034
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035 if (!dev_valid_name(dev->name)) {
3036 ret = -EINVAL;
Adrian Bunk90833aa2006-11-13 16:02:22 -08003037 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003038 }
3039
3040 dev->ifindex = dev_new_index();
3041 if (dev->iflink == -1)
3042 dev->iflink = dev->ifindex;
3043
3044 /* Check for existence of name */
3045 head = dev_name_hash(dev->name);
3046 hlist_for_each(p, head) {
3047 struct net_device *d
3048 = hlist_entry(p, struct net_device, name_hlist);
3049 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
3050 ret = -EEXIST;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003051 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003053 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003054
3055 /* Fix illegal SG+CSUM combinations. */
3056 if ((dev->features & NETIF_F_SG) &&
Herbert Xu8648b302006-06-17 22:06:05 -07003057 !(dev->features & NETIF_F_ALL_CSUM)) {
Stephen Hemminger5a8da022006-07-07 16:54:05 -07003058 printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no checksum feature.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059 dev->name);
3060 dev->features &= ~NETIF_F_SG;
3061 }
3062
3063 /* TSO requires that SG is present as well. */
3064 if ((dev->features & NETIF_F_TSO) &&
3065 !(dev->features & NETIF_F_SG)) {
Stephen Hemminger5a8da022006-07-07 16:54:05 -07003066 printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no SG feature.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067 dev->name);
3068 dev->features &= ~NETIF_F_TSO;
3069 }
Ananda Rajue89e9cf2005-10-18 15:46:41 -07003070 if (dev->features & NETIF_F_UFO) {
3071 if (!(dev->features & NETIF_F_HW_CSUM)) {
3072 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3073 "NETIF_F_HW_CSUM feature.\n",
3074 dev->name);
3075 dev->features &= ~NETIF_F_UFO;
3076 }
3077 if (!(dev->features & NETIF_F_SG)) {
3078 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3079 "NETIF_F_SG feature.\n",
3080 dev->name);
3081 dev->features &= ~NETIF_F_UFO;
3082 }
3083 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003084
3085 /*
3086 * nil rebuild_header routine,
3087 * that should be never called and used as just bug trap.
3088 */
3089
3090 if (!dev->rebuild_header)
3091 dev->rebuild_header = default_rebuild_header;
3092
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003093 ret = netdev_register_sysfs(dev);
3094 if (ret)
Adrian Bunk90833aa2006-11-13 16:02:22 -08003095 goto out;
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003096 dev->reg_state = NETREG_REGISTERED;
3097
Linus Torvalds1da177e2005-04-16 15:20:36 -07003098 /*
3099 * Default initial state at registry is that the
3100 * device is present.
3101 */
3102
3103 set_bit(__LINK_STATE_PRESENT, &dev->state);
3104
3105 dev->next = NULL;
3106 dev_init_scheduler(dev);
3107 write_lock_bh(&dev_base_lock);
3108 *dev_tail = dev;
3109 dev_tail = &dev->next;
3110 hlist_add_head(&dev->name_hlist, head);
3111 hlist_add_head(&dev->index_hlist, dev_index_hash(dev->ifindex));
3112 dev_hold(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003113 write_unlock_bh(&dev_base_lock);
3114
3115 /* Notify protocols, that a new device appeared. */
Alan Sternf07d5b92006-05-09 15:23:03 -07003116 raw_notifier_call_chain(&netdev_chain, NETDEV_REGISTER, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118 ret = 0;
3119
3120out:
3121 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003122}
3123
3124/**
3125 * register_netdev - register a network device
3126 * @dev: device to register
3127 *
3128 * Take a completed network device structure and add it to the kernel
3129 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3130 * chain. 0 is returned on success. A negative errno code is returned
3131 * on a failure to set up the device, or if the name is a duplicate.
3132 *
Borislav Petkov38b4da32007-04-20 22:14:10 -07003133 * This is a wrapper around register_netdevice that takes the rtnl semaphore
Linus Torvalds1da177e2005-04-16 15:20:36 -07003134 * and expands the device name if you passed a format string to
3135 * alloc_netdev.
3136 */
3137int register_netdev(struct net_device *dev)
3138{
3139 int err;
3140
3141 rtnl_lock();
3142
3143 /*
3144 * If the name is a format string the caller wants us to do a
3145 * name allocation.
3146 */
3147 if (strchr(dev->name, '%')) {
3148 err = dev_alloc_name(dev, dev->name);
3149 if (err < 0)
3150 goto out;
3151 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003152
Linus Torvalds1da177e2005-04-16 15:20:36 -07003153 err = register_netdevice(dev);
3154out:
3155 rtnl_unlock();
3156 return err;
3157}
3158EXPORT_SYMBOL(register_netdev);
3159
3160/*
3161 * netdev_wait_allrefs - wait until all references are gone.
3162 *
3163 * This is called when unregistering network devices.
3164 *
3165 * Any protocol or device that holds a reference should register
3166 * for netdevice notification, and cleanup and put back the
3167 * reference if they receive an UNREGISTER event.
3168 * We can get stuck here if buggy protocols don't correctly
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003169 * call dev_put.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003170 */
3171static void netdev_wait_allrefs(struct net_device *dev)
3172{
3173 unsigned long rebroadcast_time, warning_time;
3174
3175 rebroadcast_time = warning_time = jiffies;
3176 while (atomic_read(&dev->refcnt) != 0) {
3177 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
Stephen Hemminger6756ae42006-03-20 22:23:58 -08003178 rtnl_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003179
3180 /* Rebroadcast unregister notification */
Alan Sternf07d5b92006-05-09 15:23:03 -07003181 raw_notifier_call_chain(&netdev_chain,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003182 NETDEV_UNREGISTER, dev);
3183
3184 if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
3185 &dev->state)) {
3186 /* We must not have linkwatch events
3187 * pending on unregister. If this
3188 * happens, we simply run the queue
3189 * unscheduled, resulting in a noop
3190 * for this device.
3191 */
3192 linkwatch_run_queue();
3193 }
3194
Stephen Hemminger6756ae42006-03-20 22:23:58 -08003195 __rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003196
3197 rebroadcast_time = jiffies;
3198 }
3199
3200 msleep(250);
3201
3202 if (time_after(jiffies, warning_time + 10 * HZ)) {
3203 printk(KERN_EMERG "unregister_netdevice: "
3204 "waiting for %s to become free. Usage "
3205 "count = %d\n",
3206 dev->name, atomic_read(&dev->refcnt));
3207 warning_time = jiffies;
3208 }
3209 }
3210}
3211
3212/* The sequence is:
3213 *
3214 * rtnl_lock();
3215 * ...
3216 * register_netdevice(x1);
3217 * register_netdevice(x2);
3218 * ...
3219 * unregister_netdevice(y1);
3220 * unregister_netdevice(y2);
3221 * ...
3222 * rtnl_unlock();
3223 * free_netdev(y1);
3224 * free_netdev(y2);
3225 *
3226 * We are invoked by rtnl_unlock() after it drops the semaphore.
3227 * This allows us to deal with problems:
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003228 * 1) We can delete sysfs objects which invoke hotplug
Linus Torvalds1da177e2005-04-16 15:20:36 -07003229 * without deadlocking with linkwatch via keventd.
3230 * 2) Since we run with the RTNL semaphore not held, we can sleep
3231 * safely in order to wait for the netdev refcnt to drop to zero.
3232 */
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -08003233static DEFINE_MUTEX(net_todo_run_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003234void netdev_run_todo(void)
3235{
Oleg Nesterov626ab0e2006-06-23 02:05:55 -07003236 struct list_head list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237
3238 /* Need to guard against multiple cpu's getting out of order. */
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -08003239 mutex_lock(&net_todo_run_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003240
3241 /* Not safe to do outside the semaphore. We must not return
3242 * until all unregister events invoked by the local processor
3243 * have been completed (either by this todo run, or one on
3244 * another cpu).
3245 */
3246 if (list_empty(&net_todo_list))
3247 goto out;
3248
3249 /* Snapshot list, allow later requests */
3250 spin_lock(&net_todo_list_lock);
Oleg Nesterov626ab0e2006-06-23 02:05:55 -07003251 list_replace_init(&net_todo_list, &list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003252 spin_unlock(&net_todo_list_lock);
Oleg Nesterov626ab0e2006-06-23 02:05:55 -07003253
Linus Torvalds1da177e2005-04-16 15:20:36 -07003254 while (!list_empty(&list)) {
3255 struct net_device *dev
3256 = list_entry(list.next, struct net_device, todo_list);
3257 list_del(&dev->todo_list);
3258
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003259 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003260 printk(KERN_ERR "network todo '%s' but state %d\n",
3261 dev->name, dev->reg_state);
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003262 dump_stack();
3263 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003264 }
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003265
3266 netdev_unregister_sysfs(dev);
3267 dev->reg_state = NETREG_UNREGISTERED;
3268
3269 netdev_wait_allrefs(dev);
3270
3271 /* paranoia */
3272 BUG_ON(atomic_read(&dev->refcnt));
3273 BUG_TRAP(!dev->ip_ptr);
3274 BUG_TRAP(!dev->ip6_ptr);
3275 BUG_TRAP(!dev->dn_ptr);
3276
3277 /* It must be the very last action,
3278 * after this 'dev' may point to freed up memory.
3279 */
3280 if (dev->destructor)
3281 dev->destructor(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003282 }
3283
3284out:
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -08003285 mutex_unlock(&net_todo_run_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003286}
3287
Rusty Russellc45d2862007-03-28 14:29:08 -07003288static struct net_device_stats *maybe_internal_stats(struct net_device *dev)
3289{
3290 if (dev->features & NETIF_F_INTERNAL_STATS)
3291 return &dev->stats;
3292 return NULL;
3293}
3294
Linus Torvalds1da177e2005-04-16 15:20:36 -07003295/**
3296 * alloc_netdev - allocate network device
3297 * @sizeof_priv: size of private data to allocate space for
3298 * @name: device name format string
3299 * @setup: callback to initialize device
3300 *
3301 * Allocates a struct net_device with private data area for driver use
3302 * and performs basic initialization.
3303 */
3304struct net_device *alloc_netdev(int sizeof_priv, const char *name,
3305 void (*setup)(struct net_device *))
3306{
3307 void *p;
3308 struct net_device *dev;
3309 int alloc_size;
3310
Stephen Hemmingerb6fe17d2006-08-29 17:06:13 -07003311 BUG_ON(strlen(name) >= sizeof(dev->name));
3312
Linus Torvalds1da177e2005-04-16 15:20:36 -07003313 /* ensure 32-byte alignment of both the device and private area */
3314 alloc_size = (sizeof(*dev) + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
3315 alloc_size += sizeof_priv + NETDEV_ALIGN_CONST;
3316
Paolo 'Blaisorblade' Giarrusso31380de2006-04-06 22:38:28 -07003317 p = kzalloc(alloc_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003318 if (!p) {
Stephen Hemmingerb6fe17d2006-08-29 17:06:13 -07003319 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003320 return NULL;
3321 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003322
3323 dev = (struct net_device *)
3324 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
3325 dev->padded = (char *)dev - (char *)p;
3326
3327 if (sizeof_priv)
3328 dev->priv = netdev_priv(dev);
3329
Rusty Russellc45d2862007-03-28 14:29:08 -07003330 dev->get_stats = maybe_internal_stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331 setup(dev);
3332 strcpy(dev->name, name);
3333 return dev;
3334}
3335EXPORT_SYMBOL(alloc_netdev);
3336
3337/**
3338 * free_netdev - free network device
3339 * @dev: device
3340 *
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003341 * This function does the last stage of destroying an allocated device
3342 * interface. The reference to the device object is released.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003343 * If this is the last reference then it will be freed.
3344 */
3345void free_netdev(struct net_device *dev)
3346{
3347#ifdef CONFIG_SYSFS
Stephen Hemminger3041a062006-05-26 13:25:24 -07003348 /* Compatibility with error handling in drivers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003349 if (dev->reg_state == NETREG_UNINITIALIZED) {
3350 kfree((char *)dev - dev->padded);
3351 return;
3352 }
3353
3354 BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
3355 dev->reg_state = NETREG_RELEASED;
3356
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07003357 /* will free via device release */
3358 put_device(&dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003359#else
3360 kfree((char *)dev - dev->padded);
3361#endif
3362}
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003363
Linus Torvalds1da177e2005-04-16 15:20:36 -07003364/* Synchronize with packet receive processing. */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003365void synchronize_net(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003366{
3367 might_sleep();
Paul E. McKenneyfbd568a3e2005-05-01 08:59:04 -07003368 synchronize_rcu();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003369}
3370
3371/**
3372 * unregister_netdevice - remove device from the kernel
3373 * @dev: device
3374 *
3375 * This function shuts down a device interface and removes it
3376 * from the kernel tables. On success 0 is returned, on a failure
3377 * a negative errno code is returned.
3378 *
3379 * Callers must hold the rtnl semaphore. You may want
3380 * unregister_netdev() instead of this.
3381 */
3382
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08003383void unregister_netdevice(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003384{
3385 struct net_device *d, **dp;
3386
3387 BUG_ON(dev_boot_phase);
3388 ASSERT_RTNL();
3389
3390 /* Some devices call without registering for initialization unwind. */
3391 if (dev->reg_state == NETREG_UNINITIALIZED) {
3392 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3393 "was registered\n", dev->name, dev);
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08003394
3395 WARN_ON(1);
3396 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003397 }
3398
3399 BUG_ON(dev->reg_state != NETREG_REGISTERED);
3400
3401 /* If device is running, close it first. */
3402 if (dev->flags & IFF_UP)
3403 dev_close(dev);
3404
3405 /* And unlink it from device chain. */
3406 for (dp = &dev_base; (d = *dp) != NULL; dp = &d->next) {
3407 if (d == dev) {
3408 write_lock_bh(&dev_base_lock);
3409 hlist_del(&dev->name_hlist);
3410 hlist_del(&dev->index_hlist);
3411 if (dev_tail == &dev->next)
3412 dev_tail = dp;
3413 *dp = d->next;
3414 write_unlock_bh(&dev_base_lock);
3415 break;
3416 }
3417 }
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08003418 BUG_ON(!d);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419
3420 dev->reg_state = NETREG_UNREGISTERING;
3421
3422 synchronize_net();
3423
3424 /* Shutdown queueing discipline. */
3425 dev_shutdown(dev);
3426
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003427
Linus Torvalds1da177e2005-04-16 15:20:36 -07003428 /* Notify protocols, that we are about to destroy
3429 this device. They should clean all the things.
3430 */
Alan Sternf07d5b92006-05-09 15:23:03 -07003431 raw_notifier_call_chain(&netdev_chain, NETDEV_UNREGISTER, dev);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003432
Linus Torvalds1da177e2005-04-16 15:20:36 -07003433 /*
3434 * Flush the multicast chain
3435 */
3436 dev_mc_discard(dev);
3437
3438 if (dev->uninit)
3439 dev->uninit(dev);
3440
3441 /* Notifier chain MUST detach us from master device. */
3442 BUG_TRAP(!dev->master);
3443
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444 /* Finish processing unregister after unlock */
3445 net_set_todo(dev);
3446
3447 synchronize_net();
3448
3449 dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003450}
3451
3452/**
3453 * unregister_netdev - remove device from the kernel
3454 * @dev: device
3455 *
3456 * This function shuts down a device interface and removes it
3457 * from the kernel tables. On success 0 is returned, on a failure
3458 * a negative errno code is returned.
3459 *
3460 * This is just a wrapper for unregister_netdevice that takes
3461 * the rtnl semaphore. In general you want to use this and not
3462 * unregister_netdevice.
3463 */
3464void unregister_netdev(struct net_device *dev)
3465{
3466 rtnl_lock();
3467 unregister_netdevice(dev);
3468 rtnl_unlock();
3469}
3470
3471EXPORT_SYMBOL(unregister_netdev);
3472
Linus Torvalds1da177e2005-04-16 15:20:36 -07003473static int dev_cpu_callback(struct notifier_block *nfb,
3474 unsigned long action,
3475 void *ocpu)
3476{
3477 struct sk_buff **list_skb;
3478 struct net_device **list_net;
3479 struct sk_buff *skb;
3480 unsigned int cpu, oldcpu = (unsigned long)ocpu;
3481 struct softnet_data *sd, *oldsd;
3482
3483 if (action != CPU_DEAD)
3484 return NOTIFY_OK;
3485
3486 local_irq_disable();
3487 cpu = smp_processor_id();
3488 sd = &per_cpu(softnet_data, cpu);
3489 oldsd = &per_cpu(softnet_data, oldcpu);
3490
3491 /* Find end of our completion_queue. */
3492 list_skb = &sd->completion_queue;
3493 while (*list_skb)
3494 list_skb = &(*list_skb)->next;
3495 /* Append completion queue from offline CPU. */
3496 *list_skb = oldsd->completion_queue;
3497 oldsd->completion_queue = NULL;
3498
3499 /* Find end of our output_queue. */
3500 list_net = &sd->output_queue;
3501 while (*list_net)
3502 list_net = &(*list_net)->next_sched;
3503 /* Append output queue from offline CPU. */
3504 *list_net = oldsd->output_queue;
3505 oldsd->output_queue = NULL;
3506
3507 raise_softirq_irqoff(NET_TX_SOFTIRQ);
3508 local_irq_enable();
3509
3510 /* Process offline CPU's input_pkt_queue */
3511 while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
3512 netif_rx(skb);
3513
3514 return NOTIFY_OK;
3515}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003516
Chris Leechdb217332006-06-17 21:24:58 -07003517#ifdef CONFIG_NET_DMA
3518/**
3519 * net_dma_rebalance -
3520 * This is called when the number of channels allocated to the net_dma_client
3521 * changes. The net_dma_client tries to have one DMA channel per CPU.
3522 */
3523static void net_dma_rebalance(void)
3524{
3525 unsigned int cpu, i, n;
3526 struct dma_chan *chan;
3527
Chris Leechdb217332006-06-17 21:24:58 -07003528 if (net_dma_count == 0) {
3529 for_each_online_cpu(cpu)
Alexey Dobriyan29bbd722006-08-02 15:02:31 -07003530 rcu_assign_pointer(per_cpu(softnet_data, cpu).net_dma, NULL);
Chris Leechdb217332006-06-17 21:24:58 -07003531 return;
3532 }
3533
3534 i = 0;
3535 cpu = first_cpu(cpu_online_map);
3536
3537 rcu_read_lock();
3538 list_for_each_entry(chan, &net_dma_client->channels, client_node) {
3539 n = ((num_online_cpus() / net_dma_count)
3540 + (i < (num_online_cpus() % net_dma_count) ? 1 : 0));
3541
3542 while(n) {
Alexey Dobriyan29bbd722006-08-02 15:02:31 -07003543 per_cpu(softnet_data, cpu).net_dma = chan;
Chris Leechdb217332006-06-17 21:24:58 -07003544 cpu = next_cpu(cpu, cpu_online_map);
3545 n--;
3546 }
3547 i++;
3548 }
3549 rcu_read_unlock();
Chris Leechdb217332006-06-17 21:24:58 -07003550}
3551
3552/**
3553 * netdev_dma_event - event callback for the net_dma_client
3554 * @client: should always be net_dma_client
Randy Dunlapf4b8ea72006-06-22 16:00:11 -07003555 * @chan: DMA channel for the event
3556 * @event: event type
Chris Leechdb217332006-06-17 21:24:58 -07003557 */
3558static void netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
3559 enum dma_event event)
3560{
3561 spin_lock(&net_dma_event_lock);
3562 switch (event) {
3563 case DMA_RESOURCE_ADDED:
3564 net_dma_count++;
3565 net_dma_rebalance();
3566 break;
3567 case DMA_RESOURCE_REMOVED:
3568 net_dma_count--;
3569 net_dma_rebalance();
3570 break;
3571 default:
3572 break;
3573 }
3574 spin_unlock(&net_dma_event_lock);
3575}
3576
3577/**
3578 * netdev_dma_regiser - register the networking subsystem as a DMA client
3579 */
3580static int __init netdev_dma_register(void)
3581{
3582 spin_lock_init(&net_dma_event_lock);
3583 net_dma_client = dma_async_client_register(netdev_dma_event);
3584 if (net_dma_client == NULL)
3585 return -ENOMEM;
3586
3587 dma_async_client_chan_request(net_dma_client, num_online_cpus());
3588 return 0;
3589}
3590
3591#else
3592static int __init netdev_dma_register(void) { return -ENODEV; }
3593#endif /* CONFIG_NET_DMA */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003594
3595/*
3596 * Initialize the DEV module. At boot time this walks the device list and
3597 * unhooks any devices that fail to initialise (normally hardware not
3598 * present) and leaves us with a valid list of present and active devices.
3599 *
3600 */
3601
3602/*
3603 * This is called single threaded during boot, so no need
3604 * to take the rtnl semaphore.
3605 */
3606static int __init net_dev_init(void)
3607{
3608 int i, rc = -ENOMEM;
3609
3610 BUG_ON(!dev_boot_phase);
3611
Linus Torvalds1da177e2005-04-16 15:20:36 -07003612 if (dev_proc_init())
3613 goto out;
3614
3615 if (netdev_sysfs_init())
3616 goto out;
3617
3618 INIT_LIST_HEAD(&ptype_all);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003619 for (i = 0; i < 16; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003620 INIT_LIST_HEAD(&ptype_base[i]);
3621
3622 for (i = 0; i < ARRAY_SIZE(dev_name_head); i++)
3623 INIT_HLIST_HEAD(&dev_name_head[i]);
3624
3625 for (i = 0; i < ARRAY_SIZE(dev_index_head); i++)
3626 INIT_HLIST_HEAD(&dev_index_head[i]);
3627
3628 /*
3629 * Initialise the packet receive queues.
3630 */
3631
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -07003632 for_each_possible_cpu(i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003633 struct softnet_data *queue;
3634
3635 queue = &per_cpu(softnet_data, i);
3636 skb_queue_head_init(&queue->input_pkt_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003637 queue->completion_queue = NULL;
3638 INIT_LIST_HEAD(&queue->poll_list);
3639 set_bit(__LINK_STATE_START, &queue->backlog_dev.state);
3640 queue->backlog_dev.weight = weight_p;
3641 queue->backlog_dev.poll = process_backlog;
3642 atomic_set(&queue->backlog_dev.refcnt, 1);
3643 }
3644
Chris Leechdb217332006-06-17 21:24:58 -07003645 netdev_dma_register();
3646
Linus Torvalds1da177e2005-04-16 15:20:36 -07003647 dev_boot_phase = 0;
3648
3649 open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
3650 open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
3651
3652 hotcpu_notifier(dev_cpu_callback, 0);
3653 dst_init();
3654 dev_mcast_init();
3655 rc = 0;
3656out:
3657 return rc;
3658}
3659
3660subsys_initcall(net_dev_init);
3661
3662EXPORT_SYMBOL(__dev_get_by_index);
3663EXPORT_SYMBOL(__dev_get_by_name);
3664EXPORT_SYMBOL(__dev_remove_pack);
Mitch Williamsc2373ee2005-11-09 10:34:45 -08003665EXPORT_SYMBOL(dev_valid_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003666EXPORT_SYMBOL(dev_add_pack);
3667EXPORT_SYMBOL(dev_alloc_name);
3668EXPORT_SYMBOL(dev_close);
3669EXPORT_SYMBOL(dev_get_by_flags);
3670EXPORT_SYMBOL(dev_get_by_index);
3671EXPORT_SYMBOL(dev_get_by_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003672EXPORT_SYMBOL(dev_open);
3673EXPORT_SYMBOL(dev_queue_xmit);
3674EXPORT_SYMBOL(dev_remove_pack);
3675EXPORT_SYMBOL(dev_set_allmulti);
3676EXPORT_SYMBOL(dev_set_promiscuity);
3677EXPORT_SYMBOL(dev_change_flags);
3678EXPORT_SYMBOL(dev_set_mtu);
3679EXPORT_SYMBOL(dev_set_mac_address);
3680EXPORT_SYMBOL(free_netdev);
3681EXPORT_SYMBOL(netdev_boot_setup_check);
3682EXPORT_SYMBOL(netdev_set_master);
3683EXPORT_SYMBOL(netdev_state_change);
3684EXPORT_SYMBOL(netif_receive_skb);
3685EXPORT_SYMBOL(netif_rx);
3686EXPORT_SYMBOL(register_gifconf);
3687EXPORT_SYMBOL(register_netdevice);
3688EXPORT_SYMBOL(register_netdevice_notifier);
3689EXPORT_SYMBOL(skb_checksum_help);
3690EXPORT_SYMBOL(synchronize_net);
3691EXPORT_SYMBOL(unregister_netdevice);
3692EXPORT_SYMBOL(unregister_netdevice_notifier);
3693EXPORT_SYMBOL(net_enable_timestamp);
3694EXPORT_SYMBOL(net_disable_timestamp);
3695EXPORT_SYMBOL(dev_get_flags);
3696
3697#if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
3698EXPORT_SYMBOL(br_handle_frame_hook);
3699EXPORT_SYMBOL(br_fdb_get_hook);
3700EXPORT_SYMBOL(br_fdb_put_hook);
3701#endif
3702
3703#ifdef CONFIG_KMOD
3704EXPORT_SYMBOL(dev_load);
3705#endif
3706
3707EXPORT_PER_CPU_SYMBOL(softnet_data);