blob: ed49da592051f368cf32b3bafd59bd05494c3c67 [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>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020095#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070096#include <net/sock.h>
97#include <linux/rtnetlink.h>
98#include <linux/proc_fs.h>
99#include <linux/seq_file.h>
100#include <linux/stat.h>
101#include <linux/if_bridge.h>
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700102#include <linux/if_macvlan.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103#include <net/dst.h>
104#include <net/pkt_sched.h>
105#include <net/checksum.h>
106#include <linux/highmem.h>
107#include <linux/init.h>
108#include <linux/kmod.h>
109#include <linux/module.h>
110#include <linux/kallsyms.h>
111#include <linux/netpoll.h>
112#include <linux/rcupdate.h>
113#include <linux/delay.h>
Johannes Berg295f4a12007-04-26 20:43:56 -0700114#include <net/wext.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115#include <net/iw_handler.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116#include <asm/current.h>
Steve Grubb5bdb9882005-12-03 08:39:35 -0500117#include <linux/audit.h>
Chris Leechdb217332006-06-17 21:24:58 -0700118#include <linux/dmaengine.h>
Herbert Xuf6a78bf2006-06-22 02:57:17 -0700119#include <linux/err.h>
David S. Millerc7fa9d12006-08-15 16:34:13 -0700120#include <linux/ctype.h>
Jarek Poplawski723e98b72007-05-15 22:46:18 -0700121#include <linux/if_arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122
Pavel Emelyanov342709e2007-10-23 21:14:45 -0700123#include "net-sysfs.h"
124
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125/*
126 * The list of packet types we will receive (as opposed to discard)
127 * and the routines to invoke.
128 *
129 * Why 16. Because with 16 the only overlap we get on a hash of the
130 * low nibble of the protocol value is RARP/SNAP/X.25.
131 *
132 * NOTE: That is no longer true with the addition of VLAN tags. Not
133 * sure which should go first, but I bet it won't make much
134 * difference if we are running VLANs. The good news is that
135 * this protocol won't be in the list unless compiled in, so
Stephen Hemminger3041a062006-05-26 13:25:24 -0700136 * the average user (w/out VLANs) will not be adversely affected.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 * --BLG
138 *
139 * 0800 IP
140 * 8100 802.1Q VLAN
141 * 0001 802.3
142 * 0002 AX.25
143 * 0004 802.2
144 * 8035 RARP
145 * 0005 SNAP
146 * 0805 X.25
147 * 0806 ARP
148 * 8137 IPX
149 * 0009 Localtalk
150 * 86DD IPv6
151 */
152
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +0800153#define PTYPE_HASH_SIZE (16)
154#define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156static DEFINE_SPINLOCK(ptype_lock);
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +0800157static struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
Stephen Hemminger6b2bedc2007-03-12 14:33:50 -0700158static struct list_head ptype_all __read_mostly; /* Taps */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
Chris Leechdb217332006-06-17 21:24:58 -0700160#ifdef CONFIG_NET_DMA
Dan Williamsd379b012007-07-09 11:56:42 -0700161struct net_dma {
162 struct dma_client client;
163 spinlock_t lock;
164 cpumask_t channel_mask;
165 struct dma_chan *channels[NR_CPUS];
166};
167
168static enum dma_state_client
169netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
170 enum dma_state state);
171
172static struct net_dma net_dma = {
173 .client = {
174 .event_callback = netdev_dma_event,
175 },
176};
Chris Leechdb217332006-06-17 21:24:58 -0700177#endif
178
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179/*
Pavel Emelianov7562f872007-05-03 15:13:45 -0700180 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 * semaphore.
182 *
183 * Pure readers hold dev_base_lock for reading.
184 *
185 * Writers must hold the rtnl semaphore while they loop through the
Pavel Emelianov7562f872007-05-03 15:13:45 -0700186 * dev_base_head list, and hold dev_base_lock for writing when they do the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 * actual updates. This allows pure readers to access the list even
188 * while a writer is preparing to update it.
189 *
190 * To put it another way, dev_base_lock is held for writing only to
191 * protect against pure readers; the rtnl semaphore provides the
192 * protection against other writers.
193 *
194 * See, for example usages, register_netdevice() and
195 * unregister_netdevice(), which must be called with the rtnl
196 * semaphore held.
197 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198DEFINE_RWLOCK(dev_base_lock);
199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200EXPORT_SYMBOL(dev_base_lock);
201
202#define NETDEV_HASHBITS 8
Eric W. Biederman881d9662007-09-17 11:56:21 -0700203#define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Eric W. Biederman881d9662007-09-17 11:56:21 -0700205static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206{
207 unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
Eric W. Biederman881d9662007-09-17 11:56:21 -0700208 return &net->dev_name_head[hash & ((1 << NETDEV_HASHBITS) - 1)];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209}
210
Eric W. Biederman881d9662007-09-17 11:56:21 -0700211static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212{
Eric W. Biederman881d9662007-09-17 11:56:21 -0700213 return &net->dev_index_head[ifindex & ((1 << NETDEV_HASHBITS) - 1)];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214}
215
Eric W. Biedermance286d32007-09-12 13:53:49 +0200216/* Device list insertion */
217static int list_netdevice(struct net_device *dev)
218{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900219 struct net *net = dev_net(dev);
Eric W. Biedermance286d32007-09-12 13:53:49 +0200220
221 ASSERT_RTNL();
222
223 write_lock_bh(&dev_base_lock);
224 list_add_tail(&dev->dev_list, &net->dev_base_head);
225 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
226 hlist_add_head(&dev->index_hlist, dev_index_hash(net, dev->ifindex));
227 write_unlock_bh(&dev_base_lock);
228 return 0;
229}
230
231/* Device list removal */
232static void unlist_netdevice(struct net_device *dev)
233{
234 ASSERT_RTNL();
235
236 /* Unlink dev from the device chain */
237 write_lock_bh(&dev_base_lock);
238 list_del(&dev->dev_list);
239 hlist_del(&dev->name_hlist);
240 hlist_del(&dev->index_hlist);
241 write_unlock_bh(&dev_base_lock);
242}
243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244/*
245 * Our notifier list
246 */
247
Alan Sternf07d5b92006-05-09 15:23:03 -0700248static RAW_NOTIFIER_HEAD(netdev_chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
250/*
251 * Device drivers call our routines to queue packets here. We empty the
252 * queue in the local softnet handler.
253 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700254
255DEFINE_PER_CPU(struct softnet_data, softnet_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Jarek Poplawski723e98b72007-05-15 22:46:18 -0700257#ifdef CONFIG_DEBUG_LOCK_ALLOC
258/*
259 * register_netdevice() inits dev->_xmit_lock and sets lockdep class
260 * according to dev->type
261 */
262static const unsigned short netdev_lock_type[] =
263 {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
264 ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
265 ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
266 ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
267 ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
268 ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
269 ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
270 ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
271 ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
272 ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
273 ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
274 ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
275 ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
276 ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_VOID,
277 ARPHRD_NONE};
278
279static const char *netdev_lock_name[] =
280 {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
281 "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
282 "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
283 "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
284 "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
285 "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
286 "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
287 "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
288 "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
289 "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
290 "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
291 "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
292 "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
293 "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_VOID",
294 "_xmit_NONE"};
295
296static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
297
298static inline unsigned short netdev_lock_pos(unsigned short dev_type)
299{
300 int i;
301
302 for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
303 if (netdev_lock_type[i] == dev_type)
304 return i;
305 /* the last key is used by default */
306 return ARRAY_SIZE(netdev_lock_type) - 1;
307}
308
309static inline void netdev_set_lockdep_class(spinlock_t *lock,
310 unsigned short dev_type)
311{
312 int i;
313
314 i = netdev_lock_pos(dev_type);
315 lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
316 netdev_lock_name[i]);
317}
318#else
319static inline void netdev_set_lockdep_class(spinlock_t *lock,
320 unsigned short dev_type)
321{
322}
323#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
325/*******************************************************************************
326
327 Protocol management and registration routines
328
329*******************************************************************************/
330
331/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 * Add a protocol ID to the list. Now that the input handler is
333 * smarter we can dispense with all the messy stuff that used to be
334 * here.
335 *
336 * BEWARE!!! Protocol handlers, mangling input packets,
337 * MUST BE last in hash buckets and checking protocol handlers
338 * MUST start from promiscuous ptype_all chain in net_bh.
339 * It is true now, do not change it.
340 * Explanation follows: if protocol handler, mangling packet, will
341 * be the first on list, it is not able to sense, that packet
342 * is cloned and should be copied-on-write, so that it will
343 * change it and subsequent readers will get broken packet.
344 * --ANK (980803)
345 */
346
347/**
348 * dev_add_pack - add packet handler
349 * @pt: packet type declaration
350 *
351 * Add a protocol handler to the networking stack. The passed &packet_type
352 * is linked into kernel lists and may not be freed until it has been
353 * removed from the kernel lists.
354 *
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900355 * This call does not sleep therefore it can not
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 * guarantee all CPU's that are in middle of receiving packets
357 * will see the new packet type (until the next received packet).
358 */
359
360void dev_add_pack(struct packet_type *pt)
361{
362 int hash;
363
364 spin_lock_bh(&ptype_lock);
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -0700365 if (pt->type == htons(ETH_P_ALL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 list_add_rcu(&pt->list, &ptype_all);
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -0700367 else {
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +0800368 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 list_add_rcu(&pt->list, &ptype_base[hash]);
370 }
371 spin_unlock_bh(&ptype_lock);
372}
373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374/**
375 * __dev_remove_pack - remove packet handler
376 * @pt: packet type declaration
377 *
378 * Remove a protocol handler that was previously added to the kernel
379 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
380 * from the kernel lists and can be freed or reused once this function
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900381 * returns.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 *
383 * The packet type might still be in use by receivers
384 * and must not be freed until after all the CPU's have gone
385 * through a quiescent state.
386 */
387void __dev_remove_pack(struct packet_type *pt)
388{
389 struct list_head *head;
390 struct packet_type *pt1;
391
392 spin_lock_bh(&ptype_lock);
393
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -0700394 if (pt->type == htons(ETH_P_ALL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 head = &ptype_all;
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -0700396 else
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +0800397 head = &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
399 list_for_each_entry(pt1, head, list) {
400 if (pt == pt1) {
401 list_del_rcu(&pt->list);
402 goto out;
403 }
404 }
405
406 printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
407out:
408 spin_unlock_bh(&ptype_lock);
409}
410/**
411 * dev_remove_pack - remove packet handler
412 * @pt: packet type declaration
413 *
414 * Remove a protocol handler that was previously added to the kernel
415 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
416 * from the kernel lists and can be freed or reused once this function
417 * returns.
418 *
419 * This call sleeps to guarantee that no CPU is looking at the packet
420 * type after return.
421 */
422void dev_remove_pack(struct packet_type *pt)
423{
424 __dev_remove_pack(pt);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900425
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 synchronize_net();
427}
428
429/******************************************************************************
430
431 Device Boot-time Settings Routines
432
433*******************************************************************************/
434
435/* Boot time configuration table */
436static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
437
438/**
439 * netdev_boot_setup_add - add new setup entry
440 * @name: name of the device
441 * @map: configured settings for the device
442 *
443 * Adds new setup entry to the dev_boot_setup list. The function
444 * returns 0 on error and 1 on success. This is a generic routine to
445 * all netdevices.
446 */
447static int netdev_boot_setup_add(char *name, struct ifmap *map)
448{
449 struct netdev_boot_setup *s;
450 int i;
451
452 s = dev_boot_setup;
453 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
454 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
455 memset(s[i].name, 0, sizeof(s[i].name));
456 strcpy(s[i].name, name);
457 memcpy(&s[i].map, map, sizeof(s[i].map));
458 break;
459 }
460 }
461
462 return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
463}
464
465/**
466 * netdev_boot_setup_check - check boot time settings
467 * @dev: the netdevice
468 *
469 * Check boot time settings for the device.
470 * The found settings are set for the device to be used
471 * later in the device probing.
472 * Returns 0 if no settings found, 1 if they are.
473 */
474int netdev_boot_setup_check(struct net_device *dev)
475{
476 struct netdev_boot_setup *s = dev_boot_setup;
477 int i;
478
479 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
480 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
481 !strncmp(dev->name, s[i].name, strlen(s[i].name))) {
482 dev->irq = s[i].map.irq;
483 dev->base_addr = s[i].map.base_addr;
484 dev->mem_start = s[i].map.mem_start;
485 dev->mem_end = s[i].map.mem_end;
486 return 1;
487 }
488 }
489 return 0;
490}
491
492
493/**
494 * netdev_boot_base - get address from boot time settings
495 * @prefix: prefix for network device
496 * @unit: id for network device
497 *
498 * Check boot time settings for the base address of device.
499 * The found settings are set for the device to be used
500 * later in the device probing.
501 * Returns 0 if no settings found.
502 */
503unsigned long netdev_boot_base(const char *prefix, int unit)
504{
505 const struct netdev_boot_setup *s = dev_boot_setup;
506 char name[IFNAMSIZ];
507 int i;
508
509 sprintf(name, "%s%d", prefix, unit);
510
511 /*
512 * If device already registered then return base of 1
513 * to indicate not to probe for this interface
514 */
Eric W. Biederman881d9662007-09-17 11:56:21 -0700515 if (__dev_get_by_name(&init_net, name))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 return 1;
517
518 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
519 if (!strcmp(name, s[i].name))
520 return s[i].map.base_addr;
521 return 0;
522}
523
524/*
525 * Saves at boot time configured settings for any netdevice.
526 */
527int __init netdev_boot_setup(char *str)
528{
529 int ints[5];
530 struct ifmap map;
531
532 str = get_options(str, ARRAY_SIZE(ints), ints);
533 if (!str || !*str)
534 return 0;
535
536 /* Save settings */
537 memset(&map, 0, sizeof(map));
538 if (ints[0] > 0)
539 map.irq = ints[1];
540 if (ints[0] > 1)
541 map.base_addr = ints[2];
542 if (ints[0] > 2)
543 map.mem_start = ints[3];
544 if (ints[0] > 3)
545 map.mem_end = ints[4];
546
547 /* Add new entry to the list */
548 return netdev_boot_setup_add(str, &map);
549}
550
551__setup("netdev=", netdev_boot_setup);
552
553/*******************************************************************************
554
555 Device Interface Subroutines
556
557*******************************************************************************/
558
559/**
560 * __dev_get_by_name - find a device by its name
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700561 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 * @name: name to find
563 *
564 * Find an interface by name. Must be called under RTNL semaphore
565 * or @dev_base_lock. If the name is found a pointer to the device
566 * is returned. If the name is not found then %NULL is returned. The
567 * reference counters are not incremented so the caller must be
568 * careful with locks.
569 */
570
Eric W. Biederman881d9662007-09-17 11:56:21 -0700571struct net_device *__dev_get_by_name(struct net *net, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572{
573 struct hlist_node *p;
574
Eric W. Biederman881d9662007-09-17 11:56:21 -0700575 hlist_for_each(p, dev_name_hash(net, name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 struct net_device *dev
577 = hlist_entry(p, struct net_device, name_hlist);
578 if (!strncmp(dev->name, name, IFNAMSIZ))
579 return dev;
580 }
581 return NULL;
582}
583
584/**
585 * dev_get_by_name - find a device by its name
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700586 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 * @name: name to find
588 *
589 * Find an interface by name. This can be called from any
590 * context and does its own locking. The returned handle has
591 * the usage count incremented and the caller must use dev_put() to
592 * release it when it is no longer needed. %NULL is returned if no
593 * matching device is found.
594 */
595
Eric W. Biederman881d9662007-09-17 11:56:21 -0700596struct net_device *dev_get_by_name(struct net *net, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597{
598 struct net_device *dev;
599
600 read_lock(&dev_base_lock);
Eric W. Biederman881d9662007-09-17 11:56:21 -0700601 dev = __dev_get_by_name(net, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 if (dev)
603 dev_hold(dev);
604 read_unlock(&dev_base_lock);
605 return dev;
606}
607
608/**
609 * __dev_get_by_index - find a device by its ifindex
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700610 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 * @ifindex: index of device
612 *
613 * Search for an interface by index. Returns %NULL if the device
614 * is not found or a pointer to the device. The device has not
615 * had its reference counter increased so the caller must be careful
616 * about locking. The caller must hold either the RTNL semaphore
617 * or @dev_base_lock.
618 */
619
Eric W. Biederman881d9662007-09-17 11:56:21 -0700620struct net_device *__dev_get_by_index(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621{
622 struct hlist_node *p;
623
Eric W. Biederman881d9662007-09-17 11:56:21 -0700624 hlist_for_each(p, dev_index_hash(net, ifindex)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 struct net_device *dev
626 = hlist_entry(p, struct net_device, index_hlist);
627 if (dev->ifindex == ifindex)
628 return dev;
629 }
630 return NULL;
631}
632
633
634/**
635 * dev_get_by_index - find a device by its ifindex
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700636 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 * @ifindex: index of device
638 *
639 * Search for an interface by index. Returns NULL if the device
640 * is not found or a pointer to the device. The device returned has
641 * had a reference added and the pointer is safe until the user calls
642 * dev_put to indicate they have finished with it.
643 */
644
Eric W. Biederman881d9662007-09-17 11:56:21 -0700645struct net_device *dev_get_by_index(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646{
647 struct net_device *dev;
648
649 read_lock(&dev_base_lock);
Eric W. Biederman881d9662007-09-17 11:56:21 -0700650 dev = __dev_get_by_index(net, ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 if (dev)
652 dev_hold(dev);
653 read_unlock(&dev_base_lock);
654 return dev;
655}
656
657/**
658 * dev_getbyhwaddr - find a device by its hardware address
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700659 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 * @type: media type of device
661 * @ha: hardware address
662 *
663 * Search for an interface by MAC address. Returns NULL if the device
664 * is not found or a pointer to the device. The caller must hold the
665 * rtnl semaphore. The returned device has not had its ref count increased
666 * and the caller must therefore be careful about locking
667 *
668 * BUGS:
669 * If the API was consistent this would be __dev_get_by_hwaddr
670 */
671
Eric W. Biederman881d9662007-09-17 11:56:21 -0700672struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673{
674 struct net_device *dev;
675
676 ASSERT_RTNL();
677
Denis V. Lunev81103a52007-12-12 10:47:38 -0800678 for_each_netdev(net, dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 if (dev->type == type &&
680 !memcmp(dev->dev_addr, ha, dev->addr_len))
Pavel Emelianov7562f872007-05-03 15:13:45 -0700681 return dev;
682
683 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684}
685
Jochen Friedrichcf309e32005-09-22 04:44:55 -0300686EXPORT_SYMBOL(dev_getbyhwaddr);
687
Eric W. Biederman881d9662007-09-17 11:56:21 -0700688struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
Patrick McHardy4e9cac22007-05-03 03:28:13 -0700689{
690 struct net_device *dev;
691
692 ASSERT_RTNL();
Eric W. Biederman881d9662007-09-17 11:56:21 -0700693 for_each_netdev(net, dev)
Patrick McHardy4e9cac22007-05-03 03:28:13 -0700694 if (dev->type == type)
Pavel Emelianov7562f872007-05-03 15:13:45 -0700695 return dev;
696
697 return NULL;
Patrick McHardy4e9cac22007-05-03 03:28:13 -0700698}
699
700EXPORT_SYMBOL(__dev_getfirstbyhwtype);
701
Eric W. Biederman881d9662007-09-17 11:56:21 -0700702struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703{
704 struct net_device *dev;
705
706 rtnl_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -0700707 dev = __dev_getfirstbyhwtype(net, type);
Patrick McHardy4e9cac22007-05-03 03:28:13 -0700708 if (dev)
709 dev_hold(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 rtnl_unlock();
711 return dev;
712}
713
714EXPORT_SYMBOL(dev_getfirstbyhwtype);
715
716/**
717 * dev_get_by_flags - find any device with given flags
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700718 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 * @if_flags: IFF_* values
720 * @mask: bitmask of bits in if_flags to check
721 *
722 * Search for any interface with the given flags. Returns NULL if a device
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900723 * is not found or a pointer to the device. The device returned has
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 * had a reference added and the pointer is safe until the user calls
725 * dev_put to indicate they have finished with it.
726 */
727
Eric W. Biederman881d9662007-09-17 11:56:21 -0700728struct net_device * dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729{
Pavel Emelianov7562f872007-05-03 15:13:45 -0700730 struct net_device *dev, *ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
Pavel Emelianov7562f872007-05-03 15:13:45 -0700732 ret = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 read_lock(&dev_base_lock);
Eric W. Biederman881d9662007-09-17 11:56:21 -0700734 for_each_netdev(net, dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 if (((dev->flags ^ if_flags) & mask) == 0) {
736 dev_hold(dev);
Pavel Emelianov7562f872007-05-03 15:13:45 -0700737 ret = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 break;
739 }
740 }
741 read_unlock(&dev_base_lock);
Pavel Emelianov7562f872007-05-03 15:13:45 -0700742 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743}
744
745/**
746 * dev_valid_name - check if name is okay for network device
747 * @name: name string
748 *
749 * Network device names need to be valid file names to
David S. Millerc7fa9d12006-08-15 16:34:13 -0700750 * to allow sysfs to work. We also disallow any kind of
751 * whitespace.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 */
Mitch Williamsc2373ee2005-11-09 10:34:45 -0800753int dev_valid_name(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754{
David S. Millerc7fa9d12006-08-15 16:34:13 -0700755 if (*name == '\0')
756 return 0;
Stephen Hemmingerb6fe17d2006-08-29 17:06:13 -0700757 if (strlen(name) >= IFNAMSIZ)
758 return 0;
David S. Millerc7fa9d12006-08-15 16:34:13 -0700759 if (!strcmp(name, ".") || !strcmp(name, ".."))
760 return 0;
761
762 while (*name) {
763 if (*name == '/' || isspace(*name))
764 return 0;
765 name++;
766 }
767 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768}
769
770/**
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200771 * __dev_alloc_name - allocate a name for a device
772 * @net: network namespace to allocate the device name in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 * @name: name format string
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200774 * @buf: scratch buffer and result name string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 *
776 * Passed a format string - eg "lt%d" it will try and find a suitable
Stephen Hemminger3041a062006-05-26 13:25:24 -0700777 * id. It scans list of devices to build up a free map, then chooses
778 * the first empty slot. The caller must hold the dev_base or rtnl lock
779 * while allocating the name and adding the device in order to avoid
780 * duplicates.
781 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
782 * Returns the number of the unit assigned or a negative errno code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 */
784
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200785static int __dev_alloc_name(struct net *net, const char *name, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786{
787 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 const char *p;
789 const int max_netdevices = 8*PAGE_SIZE;
Stephen Hemmingercfcabdc2007-10-09 01:59:42 -0700790 unsigned long *inuse;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 struct net_device *d;
792
793 p = strnchr(name, IFNAMSIZ-1, '%');
794 if (p) {
795 /*
796 * Verify the string as this thing may have come from
797 * the user. There must be either one "%d" and no other "%"
798 * characters.
799 */
800 if (p[1] != 'd' || strchr(p + 2, '%'))
801 return -EINVAL;
802
803 /* Use one page as a bit array of possible slots */
Stephen Hemmingercfcabdc2007-10-09 01:59:42 -0700804 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 if (!inuse)
806 return -ENOMEM;
807
Eric W. Biederman881d9662007-09-17 11:56:21 -0700808 for_each_netdev(net, d) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 if (!sscanf(d->name, name, &i))
810 continue;
811 if (i < 0 || i >= max_netdevices)
812 continue;
813
814 /* avoid cases where sscanf is not exact inverse of printf */
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200815 snprintf(buf, IFNAMSIZ, name, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 if (!strncmp(buf, d->name, IFNAMSIZ))
817 set_bit(i, inuse);
818 }
819
820 i = find_first_zero_bit(inuse, max_netdevices);
821 free_page((unsigned long) inuse);
822 }
823
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200824 snprintf(buf, IFNAMSIZ, name, i);
825 if (!__dev_get_by_name(net, buf))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 return i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
828 /* It is possible to run out of possible slots
829 * when the name is long and there isn't enough space left
830 * for the digits, or if all bits are used.
831 */
832 return -ENFILE;
833}
834
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200835/**
836 * dev_alloc_name - allocate a name for a device
837 * @dev: device
838 * @name: name format string
839 *
840 * Passed a format string - eg "lt%d" it will try and find a suitable
841 * id. It scans list of devices to build up a free map, then chooses
842 * the first empty slot. The caller must hold the dev_base or rtnl lock
843 * while allocating the name and adding the device in order to avoid
844 * duplicates.
845 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
846 * Returns the number of the unit assigned or a negative errno code.
847 */
848
849int dev_alloc_name(struct net_device *dev, const char *name)
850{
851 char buf[IFNAMSIZ];
852 struct net *net;
853 int ret;
854
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900855 BUG_ON(!dev_net(dev));
856 net = dev_net(dev);
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200857 ret = __dev_alloc_name(net, name, buf);
858 if (ret >= 0)
859 strlcpy(dev->name, buf, IFNAMSIZ);
860 return ret;
861}
862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
864/**
865 * dev_change_name - change name of a device
866 * @dev: device
867 * @newname: name (or format string) must be at least IFNAMSIZ
868 *
869 * Change name of a device, can pass format strings "eth%d".
870 * for wildcarding.
871 */
872int dev_change_name(struct net_device *dev, char *newname)
873{
Herbert Xufcc5a032007-07-30 17:03:38 -0700874 char oldname[IFNAMSIZ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 int err = 0;
Herbert Xufcc5a032007-07-30 17:03:38 -0700876 int ret;
Eric W. Biederman881d9662007-09-17 11:56:21 -0700877 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
879 ASSERT_RTNL();
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900880 BUG_ON(!dev_net(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900882 net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 if (dev->flags & IFF_UP)
884 return -EBUSY;
885
886 if (!dev_valid_name(newname))
887 return -EINVAL;
888
Stephen Hemmingerc8d90dc2007-10-26 03:53:42 -0700889 if (strncmp(newname, dev->name, IFNAMSIZ) == 0)
890 return 0;
891
Herbert Xufcc5a032007-07-30 17:03:38 -0700892 memcpy(oldname, dev->name, IFNAMSIZ);
893
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 if (strchr(newname, '%')) {
895 err = dev_alloc_name(dev, newname);
896 if (err < 0)
897 return err;
898 strcpy(newname, dev->name);
899 }
Eric W. Biederman881d9662007-09-17 11:56:21 -0700900 else if (__dev_get_by_name(net, newname))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 return -EEXIST;
902 else
903 strlcpy(dev->name, newname, IFNAMSIZ);
904
Herbert Xufcc5a032007-07-30 17:03:38 -0700905rollback:
Eric W. Biederman92749822007-04-03 00:07:30 -0600906 device_rename(&dev->dev, dev->name);
Herbert Xu7f988ea2007-07-30 16:35:46 -0700907
908 write_lock_bh(&dev_base_lock);
Eric W. Biederman92749822007-04-03 00:07:30 -0600909 hlist_del(&dev->name_hlist);
Eric W. Biederman881d9662007-09-17 11:56:21 -0700910 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
Herbert Xu7f988ea2007-07-30 16:35:46 -0700911 write_unlock_bh(&dev_base_lock);
912
Pavel Emelyanov056925a2007-09-16 15:42:43 -0700913 ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
Herbert Xufcc5a032007-07-30 17:03:38 -0700914 ret = notifier_to_errno(ret);
915
916 if (ret) {
917 if (err) {
918 printk(KERN_ERR
919 "%s: name change rollback failed: %d.\n",
920 dev->name, ret);
921 } else {
922 err = ret;
923 memcpy(dev->name, oldname, IFNAMSIZ);
924 goto rollback;
925 }
926 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
928 return err;
929}
930
931/**
Stephen Hemminger3041a062006-05-26 13:25:24 -0700932 * netdev_features_change - device changes features
Stephen Hemmingerd8a33ac2005-05-29 14:13:47 -0700933 * @dev: device to cause notification
934 *
935 * Called to indicate a device has changed features.
936 */
937void netdev_features_change(struct net_device *dev)
938{
Pavel Emelyanov056925a2007-09-16 15:42:43 -0700939 call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
Stephen Hemmingerd8a33ac2005-05-29 14:13:47 -0700940}
941EXPORT_SYMBOL(netdev_features_change);
942
943/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 * netdev_state_change - device changes state
945 * @dev: device to cause notification
946 *
947 * Called to indicate a device has changed state. This function calls
948 * the notifier chains for netdev_chain and sends a NEWLINK message
949 * to the routing socket.
950 */
951void netdev_state_change(struct net_device *dev)
952{
953 if (dev->flags & IFF_UP) {
Pavel Emelyanov056925a2007-09-16 15:42:43 -0700954 call_netdevice_notifiers(NETDEV_CHANGE, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
956 }
957}
958
959/**
960 * dev_load - load a network module
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700961 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 * @name: name of interface
963 *
964 * If a network interface is not present and the process has suitable
965 * privileges this function loads the module. If module loading is not
966 * available in this kernel then it becomes a nop.
967 */
968
Eric W. Biederman881d9662007-09-17 11:56:21 -0700969void dev_load(struct net *net, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970{
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900971 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972
973 read_lock(&dev_base_lock);
Eric W. Biederman881d9662007-09-17 11:56:21 -0700974 dev = __dev_get_by_name(net, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 read_unlock(&dev_base_lock);
976
977 if (!dev && capable(CAP_SYS_MODULE))
978 request_module("%s", name);
979}
980
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981/**
982 * dev_open - prepare an interface for use.
983 * @dev: device to open
984 *
985 * Takes a device from down to up state. The device's private open
986 * function is invoked and then the multicast lists are loaded. Finally
987 * the device is moved into the up state and a %NETDEV_UP message is
988 * sent to the netdev notifier chain.
989 *
990 * Calling this function on an active interface is a nop. On a failure
991 * a negative errno code is returned.
992 */
993int dev_open(struct net_device *dev)
994{
995 int ret = 0;
996
997 /*
998 * Is it already up?
999 */
1000
1001 if (dev->flags & IFF_UP)
1002 return 0;
1003
1004 /*
1005 * Is it even present?
1006 */
1007 if (!netif_device_present(dev))
1008 return -ENODEV;
1009
1010 /*
1011 * Call device private open method
1012 */
1013 set_bit(__LINK_STATE_START, &dev->state);
Jeff Garzikbada3392007-10-23 20:19:37 -07001014
1015 if (dev->validate_addr)
1016 ret = dev->validate_addr(dev);
1017
1018 if (!ret && dev->open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 ret = dev->open(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001021 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 * If it went open OK then:
1023 */
1024
Jeff Garzikbada3392007-10-23 20:19:37 -07001025 if (ret)
1026 clear_bit(__LINK_STATE_START, &dev->state);
1027 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 /*
1029 * Set the flags.
1030 */
1031 dev->flags |= IFF_UP;
1032
1033 /*
1034 * Initialize multicasting status
1035 */
Patrick McHardy4417da62007-06-27 01:28:10 -07001036 dev_set_rx_mode(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037
1038 /*
1039 * Wakeup transmit queue engine
1040 */
1041 dev_activate(dev);
1042
1043 /*
1044 * ... and announce new interface.
1045 */
Pavel Emelyanov056925a2007-09-16 15:42:43 -07001046 call_netdevice_notifiers(NETDEV_UP, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 }
Jeff Garzikbada3392007-10-23 20:19:37 -07001048
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 return ret;
1050}
1051
1052/**
1053 * dev_close - shutdown an interface.
1054 * @dev: device to shutdown
1055 *
1056 * This function moves an active device into down state. A
1057 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1058 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1059 * chain.
1060 */
1061int dev_close(struct net_device *dev)
1062{
David S. Miller9d5010d2007-09-12 14:33:25 +02001063 might_sleep();
1064
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 if (!(dev->flags & IFF_UP))
1066 return 0;
1067
1068 /*
1069 * Tell people we are going down, so that they can
1070 * prepare to death, when device is still operating.
1071 */
Pavel Emelyanov056925a2007-09-16 15:42:43 -07001072 call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 clear_bit(__LINK_STATE_START, &dev->state);
1075
1076 /* Synchronize to scheduled poll. We cannot touch poll list,
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001077 * it can be even on different cpu. So just clear netif_running().
1078 *
1079 * dev->stop() will invoke napi_disable() on all of it's
1080 * napi_struct instances on this device.
1081 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 smp_mb__after_clear_bit(); /* Commit netif_running(). */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
Matti Linnanvuorid8b2a4d2008-02-12 23:10:11 -08001084 dev_deactivate(dev);
1085
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 /*
1087 * Call the device specific close. This cannot fail.
1088 * Only if device is UP
1089 *
1090 * We allow it to be called even after a DETACH hot-plug
1091 * event.
1092 */
1093 if (dev->stop)
1094 dev->stop(dev);
1095
1096 /*
1097 * Device is now down.
1098 */
1099
1100 dev->flags &= ~IFF_UP;
1101
1102 /*
1103 * Tell people we are down
1104 */
Pavel Emelyanov056925a2007-09-16 15:42:43 -07001105 call_netdevice_notifiers(NETDEV_DOWN, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
1107 return 0;
1108}
1109
1110
Eric W. Biederman881d9662007-09-17 11:56:21 -07001111static int dev_boot_phase = 1;
1112
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113/*
1114 * Device change register/unregister. These are not inline or static
1115 * as we export them to the world.
1116 */
1117
1118/**
1119 * register_netdevice_notifier - register a network notifier block
1120 * @nb: notifier
1121 *
1122 * Register a notifier to be called when network device events occur.
1123 * The notifier passed is linked into the kernel structures and must
1124 * not be reused until it has been unregistered. A negative errno code
1125 * is returned on a failure.
1126 *
1127 * When registered all registration and up events are replayed
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001128 * to the new notifier to allow device to have a race free
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 * view of the network device list.
1130 */
1131
1132int register_netdevice_notifier(struct notifier_block *nb)
1133{
1134 struct net_device *dev;
Herbert Xufcc5a032007-07-30 17:03:38 -07001135 struct net_device *last;
Eric W. Biederman881d9662007-09-17 11:56:21 -07001136 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 int err;
1138
1139 rtnl_lock();
Alan Sternf07d5b92006-05-09 15:23:03 -07001140 err = raw_notifier_chain_register(&netdev_chain, nb);
Herbert Xufcc5a032007-07-30 17:03:38 -07001141 if (err)
1142 goto unlock;
Eric W. Biederman881d9662007-09-17 11:56:21 -07001143 if (dev_boot_phase)
1144 goto unlock;
1145 for_each_net(net) {
1146 for_each_netdev(net, dev) {
1147 err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1148 err = notifier_to_errno(err);
1149 if (err)
1150 goto rollback;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
Eric W. Biederman881d9662007-09-17 11:56:21 -07001152 if (!(dev->flags & IFF_UP))
1153 continue;
Herbert Xufcc5a032007-07-30 17:03:38 -07001154
Eric W. Biederman881d9662007-09-17 11:56:21 -07001155 nb->notifier_call(nb, NETDEV_UP, dev);
1156 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 }
Herbert Xufcc5a032007-07-30 17:03:38 -07001158
1159unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 rtnl_unlock();
1161 return err;
Herbert Xufcc5a032007-07-30 17:03:38 -07001162
1163rollback:
1164 last = dev;
Eric W. Biederman881d9662007-09-17 11:56:21 -07001165 for_each_net(net) {
1166 for_each_netdev(net, dev) {
1167 if (dev == last)
1168 break;
Herbert Xufcc5a032007-07-30 17:03:38 -07001169
Eric W. Biederman881d9662007-09-17 11:56:21 -07001170 if (dev->flags & IFF_UP) {
1171 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1172 nb->notifier_call(nb, NETDEV_DOWN, dev);
1173 }
1174 nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
Herbert Xufcc5a032007-07-30 17:03:38 -07001175 }
Herbert Xufcc5a032007-07-30 17:03:38 -07001176 }
Pavel Emelyanovc67625a2007-11-14 15:53:16 -08001177
1178 raw_notifier_chain_unregister(&netdev_chain, nb);
Herbert Xufcc5a032007-07-30 17:03:38 -07001179 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180}
1181
1182/**
1183 * unregister_netdevice_notifier - unregister a network notifier block
1184 * @nb: notifier
1185 *
1186 * Unregister a notifier previously registered by
1187 * register_netdevice_notifier(). The notifier is unlinked into the
1188 * kernel structures and may then be reused. A negative errno code
1189 * is returned on a failure.
1190 */
1191
1192int unregister_netdevice_notifier(struct notifier_block *nb)
1193{
Herbert Xu9f514952006-03-25 01:24:25 -08001194 int err;
1195
1196 rtnl_lock();
Alan Sternf07d5b92006-05-09 15:23:03 -07001197 err = raw_notifier_chain_unregister(&netdev_chain, nb);
Herbert Xu9f514952006-03-25 01:24:25 -08001198 rtnl_unlock();
1199 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200}
1201
1202/**
1203 * call_netdevice_notifiers - call all network notifier blocks
1204 * @val: value passed unmodified to notifier function
Randy Dunlapc4ea43c2007-10-12 21:17:49 -07001205 * @dev: net_device pointer passed unmodified to notifier function
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 *
1207 * Call all network notifier blocks. Parameters and return value
Alan Sternf07d5b92006-05-09 15:23:03 -07001208 * are as for raw_notifier_call_chain().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 */
1210
Eric W. Biedermanad7379d2007-09-16 15:33:32 -07001211int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212{
Eric W. Biedermanad7379d2007-09-16 15:33:32 -07001213 return raw_notifier_call_chain(&netdev_chain, val, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214}
1215
1216/* When > 0 there are consumers of rx skb time stamps */
1217static atomic_t netstamp_needed = ATOMIC_INIT(0);
1218
1219void net_enable_timestamp(void)
1220{
1221 atomic_inc(&netstamp_needed);
1222}
1223
1224void net_disable_timestamp(void)
1225{
1226 atomic_dec(&netstamp_needed);
1227}
1228
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001229static inline void net_timestamp(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230{
1231 if (atomic_read(&netstamp_needed))
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001232 __net_timestamp(skb);
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001233 else
1234 skb->tstamp.tv64 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235}
1236
1237/*
1238 * Support routine. Sends outgoing frames to any network
1239 * taps currently in use.
1240 */
1241
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001242static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243{
1244 struct packet_type *ptype;
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001245
1246 net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247
1248 rcu_read_lock();
1249 list_for_each_entry_rcu(ptype, &ptype_all, list) {
1250 /* Never send packets back to the socket
1251 * they originated from - MvS (miquels@drinkel.ow.org)
1252 */
1253 if ((ptype->dev == dev || !ptype->dev) &&
1254 (ptype->af_packet_priv == NULL ||
1255 (struct sock *)ptype->af_packet_priv != skb->sk)) {
1256 struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1257 if (!skb2)
1258 break;
1259
1260 /* skb->nh should be correctly
1261 set by sender, so that the second statement is
1262 just protection against buggy protocols.
1263 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001264 skb_reset_mac_header(skb2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001266 if (skb_network_header(skb2) < skb2->data ||
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001267 skb2->network_header > skb2->tail) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 if (net_ratelimit())
1269 printk(KERN_CRIT "protocol %04x is "
1270 "buggy, dev %s\n",
1271 skb2->protocol, dev->name);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001272 skb_reset_network_header(skb2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 }
1274
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001275 skb2->transport_header = skb2->network_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 skb2->pkt_type = PACKET_OUTGOING;
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001277 ptype->func(skb2, skb->dev, ptype, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 }
1279 }
1280 rcu_read_unlock();
1281}
1282
Denis Vlasenko56079432006-03-29 15:57:29 -08001283
1284void __netif_schedule(struct net_device *dev)
1285{
1286 if (!test_and_set_bit(__LINK_STATE_SCHED, &dev->state)) {
1287 unsigned long flags;
1288 struct softnet_data *sd;
1289
1290 local_irq_save(flags);
1291 sd = &__get_cpu_var(softnet_data);
1292 dev->next_sched = sd->output_queue;
1293 sd->output_queue = dev;
1294 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1295 local_irq_restore(flags);
1296 }
1297}
1298EXPORT_SYMBOL(__netif_schedule);
1299
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001300void dev_kfree_skb_irq(struct sk_buff *skb)
Denis Vlasenko56079432006-03-29 15:57:29 -08001301{
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001302 if (atomic_dec_and_test(&skb->users)) {
1303 struct softnet_data *sd;
1304 unsigned long flags;
Denis Vlasenko56079432006-03-29 15:57:29 -08001305
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001306 local_irq_save(flags);
1307 sd = &__get_cpu_var(softnet_data);
1308 skb->next = sd->completion_queue;
1309 sd->completion_queue = skb;
1310 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1311 local_irq_restore(flags);
1312 }
Denis Vlasenko56079432006-03-29 15:57:29 -08001313}
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001314EXPORT_SYMBOL(dev_kfree_skb_irq);
Denis Vlasenko56079432006-03-29 15:57:29 -08001315
1316void dev_kfree_skb_any(struct sk_buff *skb)
1317{
1318 if (in_irq() || irqs_disabled())
1319 dev_kfree_skb_irq(skb);
1320 else
1321 dev_kfree_skb(skb);
1322}
1323EXPORT_SYMBOL(dev_kfree_skb_any);
1324
1325
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001326/**
1327 * netif_device_detach - mark device as removed
1328 * @dev: network device
1329 *
1330 * Mark device as removed from system and therefore no longer available.
1331 */
Denis Vlasenko56079432006-03-29 15:57:29 -08001332void netif_device_detach(struct net_device *dev)
1333{
1334 if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1335 netif_running(dev)) {
1336 netif_stop_queue(dev);
1337 }
1338}
1339EXPORT_SYMBOL(netif_device_detach);
1340
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001341/**
1342 * netif_device_attach - mark device as attached
1343 * @dev: network device
1344 *
1345 * Mark device as attached from system and restart if needed.
1346 */
Denis Vlasenko56079432006-03-29 15:57:29 -08001347void netif_device_attach(struct net_device *dev)
1348{
1349 if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1350 netif_running(dev)) {
1351 netif_wake_queue(dev);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001352 __netdev_watchdog_up(dev);
Denis Vlasenko56079432006-03-29 15:57:29 -08001353 }
1354}
1355EXPORT_SYMBOL(netif_device_attach);
1356
1357
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358/*
1359 * Invalidate hardware checksum when packet is to be mangled, and
1360 * complete checksum manually on outgoing path.
1361 */
Patrick McHardy84fa7932006-08-29 16:44:56 -07001362int skb_checksum_help(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363{
Al Virod3bc23e2006-11-14 21:24:49 -08001364 __wsum csum;
Herbert Xu663ead32007-04-09 11:59:07 -07001365 int ret = 0, offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366
Patrick McHardy84fa7932006-08-29 16:44:56 -07001367 if (skb->ip_summed == CHECKSUM_COMPLETE)
Herbert Xua430a432006-07-08 13:34:56 -07001368 goto out_set_summed;
1369
1370 if (unlikely(skb_shinfo(skb)->gso_size)) {
Herbert Xua430a432006-07-08 13:34:56 -07001371 /* Let GSO fix up the checksum. */
1372 goto out_set_summed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 }
1374
Herbert Xua0308472007-10-15 01:47:15 -07001375 offset = skb->csum_start - skb_headroom(skb);
1376 BUG_ON(offset >= skb_headlen(skb));
1377 csum = skb_checksum(skb, offset, skb->len - offset, 0);
1378
1379 offset += skb->csum_offset;
1380 BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1381
1382 if (skb_cloned(skb) &&
1383 !skb_clone_writable(skb, offset + sizeof(__sum16))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1385 if (ret)
1386 goto out;
1387 }
1388
Herbert Xua0308472007-10-15 01:47:15 -07001389 *(__sum16 *)(skb->data + offset) = csum_fold(csum);
Herbert Xua430a432006-07-08 13:34:56 -07001390out_set_summed:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 skb->ip_summed = CHECKSUM_NONE;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001392out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 return ret;
1394}
1395
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001396/**
1397 * skb_gso_segment - Perform segmentation on skb.
1398 * @skb: buffer to segment
Herbert Xu576a30e2006-06-27 13:22:38 -07001399 * @features: features for the output path (see dev->features)
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001400 *
1401 * This function segments the given skb and returns a list of segments.
Herbert Xu576a30e2006-06-27 13:22:38 -07001402 *
1403 * It may return NULL if the skb requires no segmentation. This is
1404 * only possible when GSO is used for verifying header integrity.
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001405 */
Herbert Xu576a30e2006-06-27 13:22:38 -07001406struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001407{
1408 struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1409 struct packet_type *ptype;
Al Viro252e33462006-11-14 20:48:11 -08001410 __be16 type = skb->protocol;
Herbert Xua430a432006-07-08 13:34:56 -07001411 int err;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001412
1413 BUG_ON(skb_shinfo(skb)->frag_list);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001414
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001415 skb_reset_mac_header(skb);
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001416 skb->mac_len = skb->network_header - skb->mac_header;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001417 __skb_pull(skb, skb->mac_len);
1418
Herbert Xuf9d106a2007-04-23 22:36:13 -07001419 if (WARN_ON(skb->ip_summed != CHECKSUM_PARTIAL)) {
Herbert Xua430a432006-07-08 13:34:56 -07001420 if (skb_header_cloned(skb) &&
1421 (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1422 return ERR_PTR(err);
1423 }
1424
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001425 rcu_read_lock();
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +08001426 list_for_each_entry_rcu(ptype,
1427 &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001428 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
Patrick McHardy84fa7932006-08-29 16:44:56 -07001429 if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
Herbert Xua430a432006-07-08 13:34:56 -07001430 err = ptype->gso_send_check(skb);
1431 segs = ERR_PTR(err);
1432 if (err || skb_gso_ok(skb, features))
1433 break;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001434 __skb_push(skb, (skb->data -
1435 skb_network_header(skb)));
Herbert Xua430a432006-07-08 13:34:56 -07001436 }
Herbert Xu576a30e2006-06-27 13:22:38 -07001437 segs = ptype->gso_segment(skb, features);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001438 break;
1439 }
1440 }
1441 rcu_read_unlock();
1442
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001443 __skb_push(skb, skb->data - skb_mac_header(skb));
Herbert Xu576a30e2006-06-27 13:22:38 -07001444
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001445 return segs;
1446}
1447
1448EXPORT_SYMBOL(skb_gso_segment);
1449
Herbert Xufb286bb2005-11-10 13:01:24 -08001450/* Take action when hardware reception checksum errors are detected. */
1451#ifdef CONFIG_BUG
1452void netdev_rx_csum_fault(struct net_device *dev)
1453{
1454 if (net_ratelimit()) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001455 printk(KERN_ERR "%s: hw csum failure.\n",
Stephen Hemminger246a4212005-12-08 15:21:39 -08001456 dev ? dev->name : "<unknown>");
Herbert Xufb286bb2005-11-10 13:01:24 -08001457 dump_stack();
1458 }
1459}
1460EXPORT_SYMBOL(netdev_rx_csum_fault);
1461#endif
1462
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463/* Actually, we should eliminate this check as soon as we know, that:
1464 * 1. IOMMU is present and allows to map all the memory.
1465 * 2. No high memory really exists on this machine.
1466 */
1467
1468static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1469{
Herbert Xu3d3a8532006-06-27 13:33:10 -07001470#ifdef CONFIG_HIGHMEM
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 int i;
1472
1473 if (dev->features & NETIF_F_HIGHDMA)
1474 return 0;
1475
1476 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1477 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1478 return 1;
1479
Herbert Xu3d3a8532006-06-27 13:33:10 -07001480#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 return 0;
1482}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001484struct dev_gso_cb {
1485 void (*destructor)(struct sk_buff *skb);
1486};
1487
1488#define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1489
1490static void dev_gso_skb_destructor(struct sk_buff *skb)
1491{
1492 struct dev_gso_cb *cb;
1493
1494 do {
1495 struct sk_buff *nskb = skb->next;
1496
1497 skb->next = nskb->next;
1498 nskb->next = NULL;
1499 kfree_skb(nskb);
1500 } while (skb->next);
1501
1502 cb = DEV_GSO_CB(skb);
1503 if (cb->destructor)
1504 cb->destructor(skb);
1505}
1506
1507/**
1508 * dev_gso_segment - Perform emulated hardware segmentation on skb.
1509 * @skb: buffer to segment
1510 *
1511 * This function segments the given skb and stores the list of segments
1512 * in skb->next.
1513 */
1514static int dev_gso_segment(struct sk_buff *skb)
1515{
1516 struct net_device *dev = skb->dev;
1517 struct sk_buff *segs;
Herbert Xu576a30e2006-06-27 13:22:38 -07001518 int features = dev->features & ~(illegal_highdma(dev, skb) ?
1519 NETIF_F_SG : 0);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001520
Herbert Xu576a30e2006-06-27 13:22:38 -07001521 segs = skb_gso_segment(skb, features);
1522
1523 /* Verifying header integrity only. */
1524 if (!segs)
1525 return 0;
1526
Hirofumi Nakagawa801678c2008-04-29 01:03:09 -07001527 if (IS_ERR(segs))
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001528 return PTR_ERR(segs);
1529
1530 skb->next = segs;
1531 DEV_GSO_CB(skb)->destructor = skb->destructor;
1532 skb->destructor = dev_gso_skb_destructor;
1533
1534 return 0;
1535}
1536
1537int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1538{
1539 if (likely(!skb->next)) {
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -07001540 if (!list_empty(&ptype_all))
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001541 dev_queue_xmit_nit(skb, dev);
1542
Herbert Xu576a30e2006-06-27 13:22:38 -07001543 if (netif_needs_gso(dev, skb)) {
1544 if (unlikely(dev_gso_segment(skb)))
1545 goto out_kfree_skb;
1546 if (skb->next)
1547 goto gso;
1548 }
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001549
Herbert Xu576a30e2006-06-27 13:22:38 -07001550 return dev->hard_start_xmit(skb, dev);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001551 }
1552
Herbert Xu576a30e2006-06-27 13:22:38 -07001553gso:
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001554 do {
1555 struct sk_buff *nskb = skb->next;
1556 int rc;
1557
1558 skb->next = nskb->next;
1559 nskb->next = NULL;
1560 rc = dev->hard_start_xmit(nskb, dev);
1561 if (unlikely(rc)) {
Michael Chanf54d9e82006-06-25 23:57:04 -07001562 nskb->next = skb->next;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001563 skb->next = nskb;
1564 return rc;
1565 }
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001566 if (unlikely((netif_queue_stopped(dev) ||
Pavel Emelyanov668f8952007-10-21 17:01:56 -07001567 netif_subqueue_stopped(dev, skb)) &&
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001568 skb->next))
Michael Chanf54d9e82006-06-25 23:57:04 -07001569 return NETDEV_TX_BUSY;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001570 } while (skb->next);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001571
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001572 skb->destructor = DEV_GSO_CB(skb)->destructor;
1573
1574out_kfree_skb:
1575 kfree_skb(skb);
1576 return 0;
1577}
1578
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579/**
1580 * dev_queue_xmit - transmit a buffer
1581 * @skb: buffer to transmit
1582 *
1583 * Queue a buffer for transmission to a network device. The caller must
1584 * have set the device and priority and built the buffer before calling
1585 * this function. The function can be called from an interrupt.
1586 *
1587 * A negative errno code is returned on a failure. A success does not
1588 * guarantee the frame will be transmitted as it may be dropped due
1589 * to congestion or traffic shaping.
Ben Greearaf191362005-04-24 20:12:36 -07001590 *
1591 * -----------------------------------------------------------------------------------
1592 * I notice this method can also return errors from the queue disciplines,
1593 * including NET_XMIT_DROP, which is a positive value. So, errors can also
1594 * be positive.
1595 *
1596 * Regardless of the return value, the skb is consumed, so it is currently
1597 * difficult to retry a send to this method. (You can bump the ref count
1598 * before sending to hold a reference for retry if you are careful.)
1599 *
1600 * When calling this method, interrupts MUST be enabled. This is because
1601 * the BH enable code must have IRQs enabled so that it will not deadlock.
1602 * --BLG
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 */
1604
1605int dev_queue_xmit(struct sk_buff *skb)
1606{
1607 struct net_device *dev = skb->dev;
1608 struct Qdisc *q;
1609 int rc = -ENOMEM;
1610
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001611 /* GSO will handle the following emulations directly. */
1612 if (netif_needs_gso(dev, skb))
1613 goto gso;
1614
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 if (skb_shinfo(skb)->frag_list &&
1616 !(dev->features & NETIF_F_FRAGLIST) &&
Herbert Xu364c6ba2006-06-09 16:10:40 -07001617 __skb_linearize(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 goto out_kfree_skb;
1619
1620 /* Fragmented skb is linearized if device does not support SG,
1621 * or if at least one of fragments is in highmem and device
1622 * does not support DMA from it.
1623 */
1624 if (skb_shinfo(skb)->nr_frags &&
1625 (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
Herbert Xu364c6ba2006-06-09 16:10:40 -07001626 __skb_linearize(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 goto out_kfree_skb;
1628
1629 /* If packet is not checksummed and device does not support
1630 * checksumming for this protocol, complete checksumming here.
1631 */
Herbert Xu663ead32007-04-09 11:59:07 -07001632 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1633 skb_set_transport_header(skb, skb->csum_start -
1634 skb_headroom(skb));
1635
Herbert Xua2988302007-06-28 13:44:37 -07001636 if (!(dev->features & NETIF_F_GEN_CSUM) &&
1637 !((dev->features & NETIF_F_IP_CSUM) &&
1638 skb->protocol == htons(ETH_P_IP)) &&
1639 !((dev->features & NETIF_F_IPV6_CSUM) &&
1640 skb->protocol == htons(ETH_P_IPV6)))
Herbert Xu663ead32007-04-09 11:59:07 -07001641 if (skb_checksum_help(skb))
1642 goto out_kfree_skb;
1643 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001645gso:
Eric Dumazet2d7ceec2005-09-27 15:22:58 -07001646 spin_lock_prefetch(&dev->queue_lock);
1647
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001648 /* Disable soft irqs for various locks below. Also
1649 * stops preemption for RCU.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001651 rcu_read_lock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001653 /* Updates of qdisc are serialized by queue_lock.
1654 * The struct Qdisc which is pointed to by qdisc is now a
1655 * rcu structure - it may be accessed without acquiring
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 * a lock (but the structure may be stale.) The freeing of the
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001657 * qdisc will be deferred until it's known that there are no
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 * more references to it.
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001659 *
1660 * If the qdisc has an enqueue function, we still need to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 * hold the queue_lock before calling it, since queue_lock
1662 * also serializes access to the device queue.
1663 */
1664
1665 q = rcu_dereference(dev->qdisc);
1666#ifdef CONFIG_NET_CLS_ACT
1667 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1668#endif
1669 if (q->enqueue) {
1670 /* Grab device queue */
1671 spin_lock(&dev->queue_lock);
Patrick McHardy85670cc2006-09-27 16:45:45 -07001672 q = dev->qdisc;
1673 if (q->enqueue) {
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001674 /* reset queue_mapping to zero */
Pavel Emelyanovdfa40912007-10-21 16:57:55 -07001675 skb_set_queue_mapping(skb, 0);
Patrick McHardy85670cc2006-09-27 16:45:45 -07001676 rc = q->enqueue(skb, q);
1677 qdisc_run(dev);
1678 spin_unlock(&dev->queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679
Patrick McHardy85670cc2006-09-27 16:45:45 -07001680 rc = rc == NET_XMIT_BYPASS ? NET_XMIT_SUCCESS : rc;
1681 goto out;
1682 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 spin_unlock(&dev->queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 }
1685
1686 /* The device has no queue. Common case for software devices:
1687 loopback, all the sorts of tunnels...
1688
Herbert Xu932ff272006-06-09 12:20:56 -07001689 Really, it is unlikely that netif_tx_lock protection is necessary
1690 here. (f.e. loopback and IP tunnels are clean ignoring statistics
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 counters.)
1692 However, it is possible, that they rely on protection
1693 made by us here.
1694
1695 Check this and shot the lock. It is not prone from deadlocks.
1696 Either shot noqueue qdisc, it is even simpler 8)
1697 */
1698 if (dev->flags & IFF_UP) {
1699 int cpu = smp_processor_id(); /* ok because BHs are off */
1700
1701 if (dev->xmit_lock_owner != cpu) {
1702
1703 HARD_TX_LOCK(dev, cpu);
1704
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07001705 if (!netif_queue_stopped(dev) &&
Pavel Emelyanov668f8952007-10-21 17:01:56 -07001706 !netif_subqueue_stopped(dev, skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 rc = 0;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001708 if (!dev_hard_start_xmit(skb, dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 HARD_TX_UNLOCK(dev);
1710 goto out;
1711 }
1712 }
1713 HARD_TX_UNLOCK(dev);
1714 if (net_ratelimit())
1715 printk(KERN_CRIT "Virtual device %s asks to "
1716 "queue packet!\n", dev->name);
1717 } else {
1718 /* Recursion is detected! It is possible,
1719 * unfortunately */
1720 if (net_ratelimit())
1721 printk(KERN_CRIT "Dead loop on virtual device "
1722 "%s, fix it urgently!\n", dev->name);
1723 }
1724 }
1725
1726 rc = -ENETDOWN;
Herbert Xud4828d82006-06-22 02:28:18 -07001727 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728
1729out_kfree_skb:
1730 kfree_skb(skb);
1731 return rc;
1732out:
Herbert Xud4828d82006-06-22 02:28:18 -07001733 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 return rc;
1735}
1736
1737
1738/*=======================================================================
1739 Receiver routines
1740 =======================================================================*/
1741
Stephen Hemminger6b2bedc2007-03-12 14:33:50 -07001742int netdev_max_backlog __read_mostly = 1000;
1743int netdev_budget __read_mostly = 300;
1744int weight_p __read_mostly = 64; /* old backlog weight */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745
1746DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1747
1748
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749/**
1750 * netif_rx - post buffer to the network code
1751 * @skb: buffer to post
1752 *
1753 * This function receives a packet from a device driver and queues it for
1754 * the upper (protocol) levels to process. It always succeeds. The buffer
1755 * may be dropped during processing for congestion control or by the
1756 * protocol layers.
1757 *
1758 * return values:
1759 * NET_RX_SUCCESS (no congestion)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 * NET_RX_DROP (packet was dropped)
1761 *
1762 */
1763
1764int netif_rx(struct sk_buff *skb)
1765{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 struct softnet_data *queue;
1767 unsigned long flags;
1768
1769 /* if netpoll wants it, pretend we never saw it */
1770 if (netpoll_rx(skb))
1771 return NET_RX_DROP;
1772
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001773 if (!skb->tstamp.tv64)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001774 net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775
1776 /*
1777 * The code is rearranged so that the path is the most
1778 * short when CPU is congested, but is still operating.
1779 */
1780 local_irq_save(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 queue = &__get_cpu_var(softnet_data);
1782
1783 __get_cpu_var(netdev_rx_stat).total++;
1784 if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1785 if (queue->input_pkt_queue.qlen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786enqueue:
1787 dev_hold(skb->dev);
1788 __skb_queue_tail(&queue->input_pkt_queue, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 local_irq_restore(flags);
Stephen Hemminger34008d82005-06-23 20:10:00 -07001790 return NET_RX_SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 }
1792
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001793 napi_schedule(&queue->backlog);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 goto enqueue;
1795 }
1796
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 __get_cpu_var(netdev_rx_stat).dropped++;
1798 local_irq_restore(flags);
1799
1800 kfree_skb(skb);
1801 return NET_RX_DROP;
1802}
1803
1804int netif_rx_ni(struct sk_buff *skb)
1805{
1806 int err;
1807
1808 preempt_disable();
1809 err = netif_rx(skb);
1810 if (local_softirq_pending())
1811 do_softirq();
1812 preempt_enable();
1813
1814 return err;
1815}
1816
1817EXPORT_SYMBOL(netif_rx_ni);
1818
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001819static inline struct net_device *skb_bond(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820{
1821 struct net_device *dev = skb->dev;
1822
Jay Vosburgh8f903c72006-02-21 16:36:44 -08001823 if (dev->master) {
David S. Miller7ea49ed2006-08-14 17:08:36 -07001824 if (skb_bond_should_drop(skb)) {
Jay Vosburgh8f903c72006-02-21 16:36:44 -08001825 kfree_skb(skb);
1826 return NULL;
1827 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 skb->dev = dev->master;
Jay Vosburgh8f903c72006-02-21 16:36:44 -08001829 }
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001830
1831 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832}
1833
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001834
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835static void net_tx_action(struct softirq_action *h)
1836{
1837 struct softnet_data *sd = &__get_cpu_var(softnet_data);
1838
1839 if (sd->completion_queue) {
1840 struct sk_buff *clist;
1841
1842 local_irq_disable();
1843 clist = sd->completion_queue;
1844 sd->completion_queue = NULL;
1845 local_irq_enable();
1846
1847 while (clist) {
1848 struct sk_buff *skb = clist;
1849 clist = clist->next;
1850
1851 BUG_TRAP(!atomic_read(&skb->users));
1852 __kfree_skb(skb);
1853 }
1854 }
1855
1856 if (sd->output_queue) {
1857 struct net_device *head;
1858
1859 local_irq_disable();
1860 head = sd->output_queue;
1861 sd->output_queue = NULL;
1862 local_irq_enable();
1863
1864 while (head) {
1865 struct net_device *dev = head;
1866 head = head->next_sched;
1867
1868 smp_mb__before_clear_bit();
1869 clear_bit(__LINK_STATE_SCHED, &dev->state);
1870
1871 if (spin_trylock(&dev->queue_lock)) {
1872 qdisc_run(dev);
1873 spin_unlock(&dev->queue_lock);
1874 } else {
1875 netif_schedule(dev);
1876 }
1877 }
1878 }
1879}
1880
Stephen Hemminger6f05f622007-03-08 20:46:03 -08001881static inline int deliver_skb(struct sk_buff *skb,
1882 struct packet_type *pt_prev,
1883 struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884{
1885 atomic_inc(&skb->users);
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001886 return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887}
1888
1889#if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
Stephen Hemminger6229e362007-03-21 13:38:47 -07001890/* These hooks defined here for ATM */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891struct net_bridge;
1892struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
1893 unsigned char *addr);
Stephen Hemminger6229e362007-03-21 13:38:47 -07001894void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895
Stephen Hemminger6229e362007-03-21 13:38:47 -07001896/*
1897 * If bridge module is loaded call bridging hook.
1898 * returns NULL if packet was consumed.
1899 */
1900struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
1901 struct sk_buff *skb) __read_mostly;
1902static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
1903 struct packet_type **pt_prev, int *ret,
1904 struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905{
1906 struct net_bridge_port *port;
1907
Stephen Hemminger6229e362007-03-21 13:38:47 -07001908 if (skb->pkt_type == PACKET_LOOPBACK ||
1909 (port = rcu_dereference(skb->dev->br_port)) == NULL)
1910 return skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911
1912 if (*pt_prev) {
Stephen Hemminger6229e362007-03-21 13:38:47 -07001913 *ret = deliver_skb(skb, *pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 *pt_prev = NULL;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001915 }
1916
Stephen Hemminger6229e362007-03-21 13:38:47 -07001917 return br_handle_frame_hook(port, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918}
1919#else
Stephen Hemminger6229e362007-03-21 13:38:47 -07001920#define handle_bridge(skb, pt_prev, ret, orig_dev) (skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921#endif
1922
Patrick McHardyb863ceb2007-07-14 18:55:06 -07001923#if defined(CONFIG_MACVLAN) || defined(CONFIG_MACVLAN_MODULE)
1924struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *skb) __read_mostly;
1925EXPORT_SYMBOL_GPL(macvlan_handle_frame_hook);
1926
1927static inline struct sk_buff *handle_macvlan(struct sk_buff *skb,
1928 struct packet_type **pt_prev,
1929 int *ret,
1930 struct net_device *orig_dev)
1931{
1932 if (skb->dev->macvlan_port == NULL)
1933 return skb;
1934
1935 if (*pt_prev) {
1936 *ret = deliver_skb(skb, *pt_prev, orig_dev);
1937 *pt_prev = NULL;
1938 }
1939 return macvlan_handle_frame_hook(skb);
1940}
1941#else
1942#define handle_macvlan(skb, pt_prev, ret, orig_dev) (skb)
1943#endif
1944
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945#ifdef CONFIG_NET_CLS_ACT
1946/* TODO: Maybe we should just force sch_ingress to be compiled in
1947 * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
1948 * a compare and 2 stores extra right now if we dont have it on
1949 * but have CONFIG_NET_CLS_ACT
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001950 * NOTE: This doesnt stop any functionality; if you dont have
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 * the ingress scheduler, you just cant add policies on ingress.
1952 *
1953 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001954static int ing_filter(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955{
1956 struct Qdisc *q;
1957 struct net_device *dev = skb->dev;
1958 int result = TC_ACT_OK;
Herbert Xuf697c3e2007-10-14 00:38:47 -07001959 u32 ttl = G_TC_RTTL(skb->tc_verd);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001960
Herbert Xuf697c3e2007-10-14 00:38:47 -07001961 if (MAX_RED_LOOP < ttl++) {
1962 printk(KERN_WARNING
1963 "Redir loop detected Dropping packet (%d->%d)\n",
1964 skb->iif, dev->ifindex);
1965 return TC_ACT_SHOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 }
1967
Herbert Xuf697c3e2007-10-14 00:38:47 -07001968 skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
1969 skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
1970
1971 spin_lock(&dev->ingress_lock);
1972 if ((q = dev->qdisc_ingress) != NULL)
1973 result = q->enqueue(skb, q);
1974 spin_unlock(&dev->ingress_lock);
1975
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 return result;
1977}
Herbert Xuf697c3e2007-10-14 00:38:47 -07001978
1979static inline struct sk_buff *handle_ing(struct sk_buff *skb,
1980 struct packet_type **pt_prev,
1981 int *ret, struct net_device *orig_dev)
1982{
1983 if (!skb->dev->qdisc_ingress)
1984 goto out;
1985
1986 if (*pt_prev) {
1987 *ret = deliver_skb(skb, *pt_prev, orig_dev);
1988 *pt_prev = NULL;
1989 } else {
1990 /* Huh? Why does turning on AF_PACKET affect this? */
1991 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
1992 }
1993
1994 switch (ing_filter(skb)) {
1995 case TC_ACT_SHOT:
1996 case TC_ACT_STOLEN:
1997 kfree_skb(skb);
1998 return NULL;
1999 }
2000
2001out:
2002 skb->tc_verd = 0;
2003 return skb;
2004}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005#endif
2006
Stephen Hemminger3b582cc2007-11-01 02:21:47 -07002007/**
2008 * netif_receive_skb - process receive buffer from network
2009 * @skb: buffer to process
2010 *
2011 * netif_receive_skb() is the main receive data processing function.
2012 * It always succeeds. The buffer may be dropped during processing
2013 * for congestion control or by the protocol layers.
2014 *
2015 * This function may only be called from softirq context and interrupts
2016 * should be enabled.
2017 *
2018 * Return values (usually ignored):
2019 * NET_RX_SUCCESS: no congestion
2020 * NET_RX_DROP: packet was dropped
2021 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022int netif_receive_skb(struct sk_buff *skb)
2023{
2024 struct packet_type *ptype, *pt_prev;
David S. Millerf2ccd8f2005-08-09 19:34:12 -07002025 struct net_device *orig_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 int ret = NET_RX_DROP;
Al Viro252e33462006-11-14 20:48:11 -08002027 __be16 type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028
2029 /* if we've gotten here through NAPI, check netpoll */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002030 if (netpoll_receive_skb(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 return NET_RX_DROP;
2032
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07002033 if (!skb->tstamp.tv64)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07002034 net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035
Patrick McHardyc01003c2007-03-29 11:46:52 -07002036 if (!skb->iif)
2037 skb->iif = skb->dev->ifindex;
David S. Miller86e65da2005-08-09 19:36:29 -07002038
David S. Millerf2ccd8f2005-08-09 19:34:12 -07002039 orig_dev = skb_bond(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040
Jay Vosburgh8f903c72006-02-21 16:36:44 -08002041 if (!orig_dev)
2042 return NET_RX_DROP;
2043
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044 __get_cpu_var(netdev_rx_stat).total++;
2045
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07002046 skb_reset_network_header(skb);
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03002047 skb_reset_transport_header(skb);
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07002048 skb->mac_len = skb->network_header - skb->mac_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049
2050 pt_prev = NULL;
2051
2052 rcu_read_lock();
2053
2054#ifdef CONFIG_NET_CLS_ACT
2055 if (skb->tc_verd & TC_NCLS) {
2056 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2057 goto ncls;
2058 }
2059#endif
2060
2061 list_for_each_entry_rcu(ptype, &ptype_all, list) {
2062 if (!ptype->dev || ptype->dev == skb->dev) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002063 if (pt_prev)
David S. Millerf2ccd8f2005-08-09 19:34:12 -07002064 ret = deliver_skb(skb, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 pt_prev = ptype;
2066 }
2067 }
2068
2069#ifdef CONFIG_NET_CLS_ACT
Herbert Xuf697c3e2007-10-14 00:38:47 -07002070 skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2071 if (!skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073ncls:
2074#endif
2075
Stephen Hemminger6229e362007-03-21 13:38:47 -07002076 skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
2077 if (!skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 goto out;
Patrick McHardyb863ceb2007-07-14 18:55:06 -07002079 skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
2080 if (!skb)
2081 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082
2083 type = skb->protocol;
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +08002084 list_for_each_entry_rcu(ptype,
2085 &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 if (ptype->type == type &&
2087 (!ptype->dev || ptype->dev == skb->dev)) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002088 if (pt_prev)
David S. Millerf2ccd8f2005-08-09 19:34:12 -07002089 ret = deliver_skb(skb, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090 pt_prev = ptype;
2091 }
2092 }
2093
2094 if (pt_prev) {
David S. Millerf2ccd8f2005-08-09 19:34:12 -07002095 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 } else {
2097 kfree_skb(skb);
2098 /* Jamal, now you will not able to escape explaining
2099 * me how you were going to use this. :-)
2100 */
2101 ret = NET_RX_DROP;
2102 }
2103
2104out:
2105 rcu_read_unlock();
2106 return ret;
2107}
2108
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002109static int process_backlog(struct napi_struct *napi, int quota)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110{
2111 int work = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 struct softnet_data *queue = &__get_cpu_var(softnet_data);
2113 unsigned long start_time = jiffies;
2114
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002115 napi->weight = weight_p;
2116 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 struct sk_buff *skb;
2118 struct net_device *dev;
2119
2120 local_irq_disable();
2121 skb = __skb_dequeue(&queue->input_pkt_queue);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002122 if (!skb) {
2123 __napi_complete(napi);
2124 local_irq_enable();
2125 break;
2126 }
2127
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 local_irq_enable();
2129
2130 dev = skb->dev;
2131
2132 netif_receive_skb(skb);
2133
2134 dev_put(dev);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002135 } while (++work < quota && jiffies == start_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002137 return work;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138}
2139
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002140/**
2141 * __napi_schedule - schedule for receive
Randy Dunlapc4ea43c2007-10-12 21:17:49 -07002142 * @n: entry to schedule
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002143 *
2144 * The entry's receive function will be scheduled to run
2145 */
Harvey Harrisonb5606c22008-02-13 15:03:16 -08002146void __napi_schedule(struct napi_struct *n)
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002147{
2148 unsigned long flags;
2149
2150 local_irq_save(flags);
2151 list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
2152 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2153 local_irq_restore(flags);
2154}
2155EXPORT_SYMBOL(__napi_schedule);
2156
2157
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158static void net_rx_action(struct softirq_action *h)
2159{
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002160 struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 unsigned long start_time = jiffies;
Stephen Hemminger51b0bde2005-06-23 20:14:40 -07002162 int budget = netdev_budget;
Matt Mackall53fb95d2005-08-11 19:27:43 -07002163 void *have;
2164
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 local_irq_disable();
2166
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002167 while (!list_empty(list)) {
2168 struct napi_struct *n;
2169 int work, weight;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002171 /* If softirq window is exhuasted then punt.
2172 *
2173 * Note that this is a slight policy change from the
2174 * previous NAPI code, which would allow up to 2
2175 * jiffies to pass before breaking out. The test
2176 * used to be "jiffies - start_time > 1".
2177 */
2178 if (unlikely(budget <= 0 || jiffies != start_time))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 goto softnet_break;
2180
2181 local_irq_enable();
2182
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002183 /* Even though interrupts have been re-enabled, this
2184 * access is safe because interrupts can only add new
2185 * entries to the tail of this list, and only ->poll()
2186 * calls can remove this head entry from the list.
2187 */
2188 n = list_entry(list->next, struct napi_struct, poll_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002190 have = netpoll_poll_lock(n);
2191
2192 weight = n->weight;
2193
David S. Miller0a7606c2007-10-29 21:28:47 -07002194 /* This NAPI_STATE_SCHED test is for avoiding a race
2195 * with netpoll's poll_napi(). Only the entity which
2196 * obtains the lock and sees NAPI_STATE_SCHED set will
2197 * actually make the ->poll() call. Therefore we avoid
2198 * accidently calling ->poll() when NAPI is not scheduled.
2199 */
2200 work = 0;
2201 if (test_bit(NAPI_STATE_SCHED, &n->state))
2202 work = n->poll(n, weight);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002203
2204 WARN_ON_ONCE(work > weight);
2205
2206 budget -= work;
2207
2208 local_irq_disable();
2209
2210 /* Drivers must not modify the NAPI state if they
2211 * consume the entire weight. In such cases this code
2212 * still "owns" the NAPI instance and therefore can
2213 * move the instance around on the list at-will.
2214 */
David S. Millerfed17f32008-01-07 21:00:40 -08002215 if (unlikely(work == weight)) {
2216 if (unlikely(napi_disable_pending(n)))
2217 __napi_complete(n);
2218 else
2219 list_move_tail(&n->poll_list, list);
2220 }
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002221
2222 netpoll_poll_unlock(have);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223 }
2224out:
Shannon Nelson515e06c2007-06-23 23:09:23 -07002225 local_irq_enable();
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002226
Chris Leechdb217332006-06-17 21:24:58 -07002227#ifdef CONFIG_NET_DMA
2228 /*
2229 * There may not be any more sk_buffs coming right now, so push
2230 * any pending DMA copies to hardware
2231 */
Dan Williamsd379b012007-07-09 11:56:42 -07002232 if (!cpus_empty(net_dma.channel_mask)) {
2233 int chan_idx;
2234 for_each_cpu_mask(chan_idx, net_dma.channel_mask) {
2235 struct dma_chan *chan = net_dma.channels[chan_idx];
2236 if (chan)
2237 dma_async_memcpy_issue_pending(chan);
2238 }
Chris Leechdb217332006-06-17 21:24:58 -07002239 }
2240#endif
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002241
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 return;
2243
2244softnet_break:
2245 __get_cpu_var(netdev_rx_stat).time_squeeze++;
2246 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2247 goto out;
2248}
2249
2250static gifconf_func_t * gifconf_list [NPROTO];
2251
2252/**
2253 * register_gifconf - register a SIOCGIF handler
2254 * @family: Address family
2255 * @gifconf: Function handler
2256 *
2257 * Register protocol dependent address dumping routines. The handler
2258 * that is passed must not be freed or reused until it has been replaced
2259 * by another handler.
2260 */
2261int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
2262{
2263 if (family >= NPROTO)
2264 return -EINVAL;
2265 gifconf_list[family] = gifconf;
2266 return 0;
2267}
2268
2269
2270/*
2271 * Map an interface index to its name (SIOCGIFNAME)
2272 */
2273
2274/*
2275 * We need this ioctl for efficient implementation of the
2276 * if_indextoname() function required by the IPv6 API. Without
2277 * it, we would have to search all the interfaces to find a
2278 * match. --pb
2279 */
2280
Eric W. Biederman881d9662007-09-17 11:56:21 -07002281static int dev_ifname(struct net *net, struct ifreq __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282{
2283 struct net_device *dev;
2284 struct ifreq ifr;
2285
2286 /*
2287 * Fetch the caller's info block.
2288 */
2289
2290 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2291 return -EFAULT;
2292
2293 read_lock(&dev_base_lock);
Eric W. Biederman881d9662007-09-17 11:56:21 -07002294 dev = __dev_get_by_index(net, ifr.ifr_ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295 if (!dev) {
2296 read_unlock(&dev_base_lock);
2297 return -ENODEV;
2298 }
2299
2300 strcpy(ifr.ifr_name, dev->name);
2301 read_unlock(&dev_base_lock);
2302
2303 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2304 return -EFAULT;
2305 return 0;
2306}
2307
2308/*
2309 * Perform a SIOCGIFCONF call. This structure will change
2310 * size eventually, and there is nothing I can do about it.
2311 * Thus we will need a 'compatibility mode'.
2312 */
2313
Eric W. Biederman881d9662007-09-17 11:56:21 -07002314static int dev_ifconf(struct net *net, char __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315{
2316 struct ifconf ifc;
2317 struct net_device *dev;
2318 char __user *pos;
2319 int len;
2320 int total;
2321 int i;
2322
2323 /*
2324 * Fetch the caller's info block.
2325 */
2326
2327 if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2328 return -EFAULT;
2329
2330 pos = ifc.ifc_buf;
2331 len = ifc.ifc_len;
2332
2333 /*
2334 * Loop over the interfaces, and write an info block for each.
2335 */
2336
2337 total = 0;
Eric W. Biederman881d9662007-09-17 11:56:21 -07002338 for_each_netdev(net, dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339 for (i = 0; i < NPROTO; i++) {
2340 if (gifconf_list[i]) {
2341 int done;
2342 if (!pos)
2343 done = gifconf_list[i](dev, NULL, 0);
2344 else
2345 done = gifconf_list[i](dev, pos + total,
2346 len - total);
2347 if (done < 0)
2348 return -EFAULT;
2349 total += done;
2350 }
2351 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002352 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353
2354 /*
2355 * All done. Write the updated control block back to the caller.
2356 */
2357 ifc.ifc_len = total;
2358
2359 /*
2360 * Both BSD and Solaris return 0 here, so we do too.
2361 */
2362 return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2363}
2364
2365#ifdef CONFIG_PROC_FS
2366/*
2367 * This is invoked by the /proc filesystem handler to display a device
2368 * in detail.
2369 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370void *dev_seq_start(struct seq_file *seq, loff_t *pos)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002371 __acquires(dev_base_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372{
Denis V. Luneve372c412007-11-19 22:31:54 -08002373 struct net *net = seq_file_net(seq);
Pavel Emelianov7562f872007-05-03 15:13:45 -07002374 loff_t off;
2375 struct net_device *dev;
2376
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 read_lock(&dev_base_lock);
Pavel Emelianov7562f872007-05-03 15:13:45 -07002378 if (!*pos)
2379 return SEQ_START_TOKEN;
2380
2381 off = 1;
Eric W. Biederman881d9662007-09-17 11:56:21 -07002382 for_each_netdev(net, dev)
Pavel Emelianov7562f872007-05-03 15:13:45 -07002383 if (off++ == *pos)
2384 return dev;
2385
2386 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387}
2388
2389void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2390{
Denis V. Luneve372c412007-11-19 22:31:54 -08002391 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392 ++*pos;
Pavel Emelianov7562f872007-05-03 15:13:45 -07002393 return v == SEQ_START_TOKEN ?
Eric W. Biederman881d9662007-09-17 11:56:21 -07002394 first_net_device(net) : next_net_device((struct net_device *)v);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395}
2396
2397void dev_seq_stop(struct seq_file *seq, void *v)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002398 __releases(dev_base_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399{
2400 read_unlock(&dev_base_lock);
2401}
2402
2403static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2404{
Rusty Russellc45d2862007-03-28 14:29:08 -07002405 struct net_device_stats *stats = dev->get_stats(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406
Rusty Russell5a1b5892007-04-28 21:04:03 -07002407 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2408 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2409 dev->name, stats->rx_bytes, stats->rx_packets,
2410 stats->rx_errors,
2411 stats->rx_dropped + stats->rx_missed_errors,
2412 stats->rx_fifo_errors,
2413 stats->rx_length_errors + stats->rx_over_errors +
2414 stats->rx_crc_errors + stats->rx_frame_errors,
2415 stats->rx_compressed, stats->multicast,
2416 stats->tx_bytes, stats->tx_packets,
2417 stats->tx_errors, stats->tx_dropped,
2418 stats->tx_fifo_errors, stats->collisions,
2419 stats->tx_carrier_errors +
2420 stats->tx_aborted_errors +
2421 stats->tx_window_errors +
2422 stats->tx_heartbeat_errors,
2423 stats->tx_compressed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424}
2425
2426/*
2427 * Called from the PROCfs module. This now uses the new arbitrary sized
2428 * /proc/net interface to create /proc/net/dev
2429 */
2430static int dev_seq_show(struct seq_file *seq, void *v)
2431{
2432 if (v == SEQ_START_TOKEN)
2433 seq_puts(seq, "Inter-| Receive "
2434 " | Transmit\n"
2435 " face |bytes packets errs drop fifo frame "
2436 "compressed multicast|bytes packets errs "
2437 "drop fifo colls carrier compressed\n");
2438 else
2439 dev_seq_printf_stats(seq, v);
2440 return 0;
2441}
2442
2443static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2444{
2445 struct netif_rx_stats *rc = NULL;
2446
2447 while (*pos < NR_CPUS)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002448 if (cpu_online(*pos)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449 rc = &per_cpu(netdev_rx_stat, *pos);
2450 break;
2451 } else
2452 ++*pos;
2453 return rc;
2454}
2455
2456static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2457{
2458 return softnet_get_online(pos);
2459}
2460
2461static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2462{
2463 ++*pos;
2464 return softnet_get_online(pos);
2465}
2466
2467static void softnet_seq_stop(struct seq_file *seq, void *v)
2468{
2469}
2470
2471static int softnet_seq_show(struct seq_file *seq, void *v)
2472{
2473 struct netif_rx_stats *s = v;
2474
2475 seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
Stephen Hemminger31aa02c2005-06-23 20:12:48 -07002476 s->total, s->dropped, s->time_squeeze, 0,
Stephen Hemmingerc1ebcdb2005-06-23 20:08:59 -07002477 0, 0, 0, 0, /* was fastroute */
2478 s->cpu_collision );
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479 return 0;
2480}
2481
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002482static const struct seq_operations dev_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 .start = dev_seq_start,
2484 .next = dev_seq_next,
2485 .stop = dev_seq_stop,
2486 .show = dev_seq_show,
2487};
2488
2489static int dev_seq_open(struct inode *inode, struct file *file)
2490{
Denis V. Luneve372c412007-11-19 22:31:54 -08002491 return seq_open_net(inode, file, &dev_seq_ops,
2492 sizeof(struct seq_net_private));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493}
2494
Arjan van de Ven9a321442007-02-12 00:55:35 -08002495static const struct file_operations dev_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 .owner = THIS_MODULE,
2497 .open = dev_seq_open,
2498 .read = seq_read,
2499 .llseek = seq_lseek,
Denis V. Luneve372c412007-11-19 22:31:54 -08002500 .release = seq_release_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501};
2502
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002503static const struct seq_operations softnet_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504 .start = softnet_seq_start,
2505 .next = softnet_seq_next,
2506 .stop = softnet_seq_stop,
2507 .show = softnet_seq_show,
2508};
2509
2510static int softnet_seq_open(struct inode *inode, struct file *file)
2511{
2512 return seq_open(file, &softnet_seq_ops);
2513}
2514
Arjan van de Ven9a321442007-02-12 00:55:35 -08002515static const struct file_operations softnet_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516 .owner = THIS_MODULE,
2517 .open = softnet_seq_open,
2518 .read = seq_read,
2519 .llseek = seq_lseek,
2520 .release = seq_release,
2521};
2522
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002523static void *ptype_get_idx(loff_t pos)
2524{
2525 struct packet_type *pt = NULL;
2526 loff_t i = 0;
2527 int t;
2528
2529 list_for_each_entry_rcu(pt, &ptype_all, list) {
2530 if (i == pos)
2531 return pt;
2532 ++i;
2533 }
2534
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +08002535 for (t = 0; t < PTYPE_HASH_SIZE; t++) {
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002536 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
2537 if (i == pos)
2538 return pt;
2539 ++i;
2540 }
2541 }
2542 return NULL;
2543}
2544
2545static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
Stephen Hemminger72348a422008-01-21 02:27:29 -08002546 __acquires(RCU)
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002547{
2548 rcu_read_lock();
2549 return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
2550}
2551
2552static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2553{
2554 struct packet_type *pt;
2555 struct list_head *nxt;
2556 int hash;
2557
2558 ++*pos;
2559 if (v == SEQ_START_TOKEN)
2560 return ptype_get_idx(0);
2561
2562 pt = v;
2563 nxt = pt->list.next;
2564 if (pt->type == htons(ETH_P_ALL)) {
2565 if (nxt != &ptype_all)
2566 goto found;
2567 hash = 0;
2568 nxt = ptype_base[0].next;
2569 } else
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +08002570 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002571
2572 while (nxt == &ptype_base[hash]) {
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +08002573 if (++hash >= PTYPE_HASH_SIZE)
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002574 return NULL;
2575 nxt = ptype_base[hash].next;
2576 }
2577found:
2578 return list_entry(nxt, struct packet_type, list);
2579}
2580
2581static void ptype_seq_stop(struct seq_file *seq, void *v)
Stephen Hemminger72348a422008-01-21 02:27:29 -08002582 __releases(RCU)
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002583{
2584 rcu_read_unlock();
2585}
2586
2587static void ptype_seq_decode(struct seq_file *seq, void *sym)
2588{
2589#ifdef CONFIG_KALLSYMS
2590 unsigned long offset = 0, symsize;
2591 const char *symname;
2592 char *modname;
2593 char namebuf[128];
2594
2595 symname = kallsyms_lookup((unsigned long)sym, &symsize, &offset,
2596 &modname, namebuf);
2597
2598 if (symname) {
2599 char *delim = ":";
2600
2601 if (!modname)
2602 modname = delim = "";
2603 seq_printf(seq, "%s%s%s%s+0x%lx", delim, modname, delim,
2604 symname, offset);
2605 return;
2606 }
2607#endif
2608
2609 seq_printf(seq, "[%p]", sym);
2610}
2611
2612static int ptype_seq_show(struct seq_file *seq, void *v)
2613{
2614 struct packet_type *pt = v;
2615
2616 if (v == SEQ_START_TOKEN)
2617 seq_puts(seq, "Type Device Function\n");
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002618 else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002619 if (pt->type == htons(ETH_P_ALL))
2620 seq_puts(seq, "ALL ");
2621 else
2622 seq_printf(seq, "%04x", ntohs(pt->type));
2623
2624 seq_printf(seq, " %-8s ",
2625 pt->dev ? pt->dev->name : "");
2626 ptype_seq_decode(seq, pt->func);
2627 seq_putc(seq, '\n');
2628 }
2629
2630 return 0;
2631}
2632
2633static const struct seq_operations ptype_seq_ops = {
2634 .start = ptype_seq_start,
2635 .next = ptype_seq_next,
2636 .stop = ptype_seq_stop,
2637 .show = ptype_seq_show,
2638};
2639
2640static int ptype_seq_open(struct inode *inode, struct file *file)
2641{
Pavel Emelyanov2feb27d2008-03-24 14:57:45 -07002642 return seq_open_net(inode, file, &ptype_seq_ops,
2643 sizeof(struct seq_net_private));
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002644}
2645
2646static const struct file_operations ptype_seq_fops = {
2647 .owner = THIS_MODULE,
2648 .open = ptype_seq_open,
2649 .read = seq_read,
2650 .llseek = seq_lseek,
Pavel Emelyanov2feb27d2008-03-24 14:57:45 -07002651 .release = seq_release_net,
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002652};
2653
2654
Pavel Emelyanov46650792007-10-08 20:38:39 -07002655static int __net_init dev_proc_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656{
2657 int rc = -ENOMEM;
2658
Eric W. Biederman881d9662007-09-17 11:56:21 -07002659 if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660 goto out;
Eric W. Biederman881d9662007-09-17 11:56:21 -07002661 if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002662 goto out_dev;
Eric W. Biederman881d9662007-09-17 11:56:21 -07002663 if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02002664 goto out_softnet;
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07002665
Eric W. Biederman881d9662007-09-17 11:56:21 -07002666 if (wext_proc_init(net))
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02002667 goto out_ptype;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668 rc = 0;
2669out:
2670 return rc;
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02002671out_ptype:
Eric W. Biederman881d9662007-09-17 11:56:21 -07002672 proc_net_remove(net, "ptype");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673out_softnet:
Eric W. Biederman881d9662007-09-17 11:56:21 -07002674 proc_net_remove(net, "softnet_stat");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675out_dev:
Eric W. Biederman881d9662007-09-17 11:56:21 -07002676 proc_net_remove(net, "dev");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002677 goto out;
2678}
Eric W. Biederman881d9662007-09-17 11:56:21 -07002679
Pavel Emelyanov46650792007-10-08 20:38:39 -07002680static void __net_exit dev_proc_net_exit(struct net *net)
Eric W. Biederman881d9662007-09-17 11:56:21 -07002681{
2682 wext_proc_exit(net);
2683
2684 proc_net_remove(net, "ptype");
2685 proc_net_remove(net, "softnet_stat");
2686 proc_net_remove(net, "dev");
2687}
2688
Denis V. Lunev022cbae2007-11-13 03:23:50 -08002689static struct pernet_operations __net_initdata dev_proc_ops = {
Eric W. Biederman881d9662007-09-17 11:56:21 -07002690 .init = dev_proc_net_init,
2691 .exit = dev_proc_net_exit,
2692};
2693
2694static int __init dev_proc_init(void)
2695{
2696 return register_pernet_subsys(&dev_proc_ops);
2697}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698#else
2699#define dev_proc_init() 0
2700#endif /* CONFIG_PROC_FS */
2701
2702
2703/**
2704 * netdev_set_master - set up master/slave pair
2705 * @slave: slave device
2706 * @master: new master device
2707 *
2708 * Changes the master device of the slave. Pass %NULL to break the
2709 * bonding. The caller must hold the RTNL semaphore. On a failure
2710 * a negative errno code is returned. On success the reference counts
2711 * are adjusted, %RTM_NEWLINK is sent to the routing socket and the
2712 * function returns zero.
2713 */
2714int netdev_set_master(struct net_device *slave, struct net_device *master)
2715{
2716 struct net_device *old = slave->master;
2717
2718 ASSERT_RTNL();
2719
2720 if (master) {
2721 if (old)
2722 return -EBUSY;
2723 dev_hold(master);
2724 }
2725
2726 slave->master = master;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002727
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728 synchronize_net();
2729
2730 if (old)
2731 dev_put(old);
2732
2733 if (master)
2734 slave->flags |= IFF_SLAVE;
2735 else
2736 slave->flags &= ~IFF_SLAVE;
2737
2738 rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2739 return 0;
2740}
2741
Patrick McHardy4417da62007-06-27 01:28:10 -07002742static void __dev_set_promiscuity(struct net_device *dev, int inc)
2743{
2744 unsigned short old_flags = dev->flags;
2745
Patrick McHardy24023452007-07-14 18:51:31 -07002746 ASSERT_RTNL();
2747
Patrick McHardy4417da62007-06-27 01:28:10 -07002748 if ((dev->promiscuity += inc) == 0)
2749 dev->flags &= ~IFF_PROMISC;
2750 else
2751 dev->flags |= IFF_PROMISC;
2752 if (dev->flags != old_flags) {
2753 printk(KERN_INFO "device %s %s promiscuous mode\n",
2754 dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
2755 "left");
Klaus Heinrich Kiwi7759db82008-01-23 22:57:45 -05002756 if (audit_enabled)
2757 audit_log(current->audit_context, GFP_ATOMIC,
2758 AUDIT_ANOM_PROMISCUOUS,
2759 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
2760 dev->name, (dev->flags & IFF_PROMISC),
2761 (old_flags & IFF_PROMISC),
2762 audit_get_loginuid(current),
2763 current->uid, current->gid,
2764 audit_get_sessionid(current));
Patrick McHardy24023452007-07-14 18:51:31 -07002765
2766 if (dev->change_rx_flags)
2767 dev->change_rx_flags(dev, IFF_PROMISC);
Patrick McHardy4417da62007-06-27 01:28:10 -07002768 }
2769}
2770
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771/**
2772 * dev_set_promiscuity - update promiscuity count on a device
2773 * @dev: device
2774 * @inc: modifier
2775 *
Stephen Hemminger3041a062006-05-26 13:25:24 -07002776 * Add or remove promiscuity from a device. While the count in the device
Linus Torvalds1da177e2005-04-16 15:20:36 -07002777 * remains above zero the interface remains promiscuous. Once it hits zero
2778 * the device reverts back to normal filtering operation. A negative inc
2779 * value is used to drop promiscuity on the device.
2780 */
2781void dev_set_promiscuity(struct net_device *dev, int inc)
2782{
2783 unsigned short old_flags = dev->flags;
2784
Patrick McHardy4417da62007-06-27 01:28:10 -07002785 __dev_set_promiscuity(dev, inc);
2786 if (dev->flags != old_flags)
2787 dev_set_rx_mode(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002788}
2789
2790/**
2791 * dev_set_allmulti - update allmulti count on a device
2792 * @dev: device
2793 * @inc: modifier
2794 *
2795 * Add or remove reception of all multicast frames to a device. While the
2796 * count in the device remains above zero the interface remains listening
2797 * to all interfaces. Once it hits zero the device reverts back to normal
2798 * filtering operation. A negative @inc value is used to drop the counter
2799 * when releasing a resource needing all multicasts.
2800 */
2801
2802void dev_set_allmulti(struct net_device *dev, int inc)
2803{
2804 unsigned short old_flags = dev->flags;
2805
Patrick McHardy24023452007-07-14 18:51:31 -07002806 ASSERT_RTNL();
2807
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808 dev->flags |= IFF_ALLMULTI;
2809 if ((dev->allmulti += inc) == 0)
2810 dev->flags &= ~IFF_ALLMULTI;
Patrick McHardy24023452007-07-14 18:51:31 -07002811 if (dev->flags ^ old_flags) {
2812 if (dev->change_rx_flags)
2813 dev->change_rx_flags(dev, IFF_ALLMULTI);
Patrick McHardy4417da62007-06-27 01:28:10 -07002814 dev_set_rx_mode(dev);
Patrick McHardy24023452007-07-14 18:51:31 -07002815 }
Patrick McHardy4417da62007-06-27 01:28:10 -07002816}
2817
2818/*
2819 * Upload unicast and multicast address lists to device and
2820 * configure RX filtering. When the device doesn't support unicast
Joe Perches53ccaae2007-12-20 14:02:06 -08002821 * filtering it is put in promiscuous mode while unicast addresses
Patrick McHardy4417da62007-06-27 01:28:10 -07002822 * are present.
2823 */
2824void __dev_set_rx_mode(struct net_device *dev)
2825{
2826 /* dev_open will call this function so the list will stay sane. */
2827 if (!(dev->flags&IFF_UP))
2828 return;
2829
2830 if (!netif_device_present(dev))
YOSHIFUJI Hideaki40b77c92007-07-19 10:43:23 +09002831 return;
Patrick McHardy4417da62007-06-27 01:28:10 -07002832
2833 if (dev->set_rx_mode)
2834 dev->set_rx_mode(dev);
2835 else {
2836 /* Unicast addresses changes may only happen under the rtnl,
2837 * therefore calling __dev_set_promiscuity here is safe.
2838 */
2839 if (dev->uc_count > 0 && !dev->uc_promisc) {
2840 __dev_set_promiscuity(dev, 1);
2841 dev->uc_promisc = 1;
2842 } else if (dev->uc_count == 0 && dev->uc_promisc) {
2843 __dev_set_promiscuity(dev, -1);
2844 dev->uc_promisc = 0;
2845 }
2846
2847 if (dev->set_multicast_list)
2848 dev->set_multicast_list(dev);
2849 }
2850}
2851
2852void dev_set_rx_mode(struct net_device *dev)
2853{
2854 netif_tx_lock_bh(dev);
2855 __dev_set_rx_mode(dev);
2856 netif_tx_unlock_bh(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002857}
2858
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07002859int __dev_addr_delete(struct dev_addr_list **list, int *count,
2860 void *addr, int alen, int glbl)
Patrick McHardybf742482007-06-27 01:26:19 -07002861{
2862 struct dev_addr_list *da;
2863
2864 for (; (da = *list) != NULL; list = &da->next) {
2865 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
2866 alen == da->da_addrlen) {
2867 if (glbl) {
2868 int old_glbl = da->da_gusers;
2869 da->da_gusers = 0;
2870 if (old_glbl == 0)
2871 break;
2872 }
2873 if (--da->da_users)
2874 return 0;
2875
2876 *list = da->next;
2877 kfree(da);
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07002878 (*count)--;
Patrick McHardybf742482007-06-27 01:26:19 -07002879 return 0;
2880 }
2881 }
2882 return -ENOENT;
2883}
2884
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07002885int __dev_addr_add(struct dev_addr_list **list, int *count,
2886 void *addr, int alen, int glbl)
Patrick McHardybf742482007-06-27 01:26:19 -07002887{
2888 struct dev_addr_list *da;
2889
2890 for (da = *list; da != NULL; da = da->next) {
2891 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
2892 da->da_addrlen == alen) {
2893 if (glbl) {
2894 int old_glbl = da->da_gusers;
2895 da->da_gusers = 1;
2896 if (old_glbl)
2897 return 0;
2898 }
2899 da->da_users++;
2900 return 0;
2901 }
2902 }
2903
Jorge Boncompte [DTI2]12aa3432008-02-19 14:17:04 -08002904 da = kzalloc(sizeof(*da), GFP_ATOMIC);
Patrick McHardybf742482007-06-27 01:26:19 -07002905 if (da == NULL)
2906 return -ENOMEM;
2907 memcpy(da->da_addr, addr, alen);
2908 da->da_addrlen = alen;
2909 da->da_users = 1;
2910 da->da_gusers = glbl ? 1 : 0;
2911 da->next = *list;
2912 *list = da;
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07002913 (*count)++;
Patrick McHardybf742482007-06-27 01:26:19 -07002914 return 0;
2915}
2916
Patrick McHardy4417da62007-06-27 01:28:10 -07002917/**
2918 * dev_unicast_delete - Release secondary unicast address.
2919 * @dev: device
Randy Dunlap0ed72ec2007-07-26 00:03:29 -07002920 * @addr: address to delete
2921 * @alen: length of @addr
Patrick McHardy4417da62007-06-27 01:28:10 -07002922 *
2923 * Release reference to a secondary unicast address and remove it
Randy Dunlap0ed72ec2007-07-26 00:03:29 -07002924 * from the device if the reference count drops to zero.
Patrick McHardy4417da62007-06-27 01:28:10 -07002925 *
2926 * The caller must hold the rtnl_mutex.
2927 */
2928int dev_unicast_delete(struct net_device *dev, void *addr, int alen)
2929{
2930 int err;
2931
2932 ASSERT_RTNL();
2933
2934 netif_tx_lock_bh(dev);
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07002935 err = __dev_addr_delete(&dev->uc_list, &dev->uc_count, addr, alen, 0);
2936 if (!err)
Patrick McHardy4417da62007-06-27 01:28:10 -07002937 __dev_set_rx_mode(dev);
Patrick McHardy4417da62007-06-27 01:28:10 -07002938 netif_tx_unlock_bh(dev);
2939 return err;
2940}
2941EXPORT_SYMBOL(dev_unicast_delete);
2942
2943/**
2944 * dev_unicast_add - add a secondary unicast address
2945 * @dev: device
Randy Dunlap0ed72ec2007-07-26 00:03:29 -07002946 * @addr: address to delete
2947 * @alen: length of @addr
Patrick McHardy4417da62007-06-27 01:28:10 -07002948 *
2949 * Add a secondary unicast address to the device or increase
2950 * the reference count if it already exists.
2951 *
2952 * The caller must hold the rtnl_mutex.
2953 */
2954int dev_unicast_add(struct net_device *dev, void *addr, int alen)
2955{
2956 int err;
2957
2958 ASSERT_RTNL();
2959
2960 netif_tx_lock_bh(dev);
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07002961 err = __dev_addr_add(&dev->uc_list, &dev->uc_count, addr, alen, 0);
2962 if (!err)
Patrick McHardy4417da62007-06-27 01:28:10 -07002963 __dev_set_rx_mode(dev);
Patrick McHardy4417da62007-06-27 01:28:10 -07002964 netif_tx_unlock_bh(dev);
2965 return err;
2966}
2967EXPORT_SYMBOL(dev_unicast_add);
2968
Chris Leeche83a2ea2008-01-31 16:53:23 -08002969int __dev_addr_sync(struct dev_addr_list **to, int *to_count,
2970 struct dev_addr_list **from, int *from_count)
2971{
2972 struct dev_addr_list *da, *next;
2973 int err = 0;
2974
2975 da = *from;
2976 while (da != NULL) {
2977 next = da->next;
2978 if (!da->da_synced) {
2979 err = __dev_addr_add(to, to_count,
2980 da->da_addr, da->da_addrlen, 0);
2981 if (err < 0)
2982 break;
2983 da->da_synced = 1;
2984 da->da_users++;
2985 } else if (da->da_users == 1) {
2986 __dev_addr_delete(to, to_count,
2987 da->da_addr, da->da_addrlen, 0);
2988 __dev_addr_delete(from, from_count,
2989 da->da_addr, da->da_addrlen, 0);
2990 }
2991 da = next;
2992 }
2993 return err;
2994}
2995
2996void __dev_addr_unsync(struct dev_addr_list **to, int *to_count,
2997 struct dev_addr_list **from, int *from_count)
2998{
2999 struct dev_addr_list *da, *next;
3000
3001 da = *from;
3002 while (da != NULL) {
3003 next = da->next;
3004 if (da->da_synced) {
3005 __dev_addr_delete(to, to_count,
3006 da->da_addr, da->da_addrlen, 0);
3007 da->da_synced = 0;
3008 __dev_addr_delete(from, from_count,
3009 da->da_addr, da->da_addrlen, 0);
3010 }
3011 da = next;
3012 }
3013}
3014
3015/**
3016 * dev_unicast_sync - Synchronize device's unicast list to another device
3017 * @to: destination device
3018 * @from: source device
3019 *
3020 * Add newly added addresses to the destination device and release
3021 * addresses that have no users left. The source device must be
3022 * locked by netif_tx_lock_bh.
3023 *
3024 * This function is intended to be called from the dev->set_rx_mode
3025 * function of layered software devices.
3026 */
3027int dev_unicast_sync(struct net_device *to, struct net_device *from)
3028{
3029 int err = 0;
3030
3031 netif_tx_lock_bh(to);
3032 err = __dev_addr_sync(&to->uc_list, &to->uc_count,
3033 &from->uc_list, &from->uc_count);
3034 if (!err)
3035 __dev_set_rx_mode(to);
3036 netif_tx_unlock_bh(to);
3037 return err;
3038}
3039EXPORT_SYMBOL(dev_unicast_sync);
3040
3041/**
Randy Dunlapbc2cda12008-02-13 15:03:25 -08003042 * dev_unicast_unsync - Remove synchronized addresses from the destination device
Chris Leeche83a2ea2008-01-31 16:53:23 -08003043 * @to: destination device
3044 * @from: source device
3045 *
3046 * Remove all addresses that were added to the destination device by
3047 * dev_unicast_sync(). This function is intended to be called from the
3048 * dev->stop function of layered software devices.
3049 */
3050void dev_unicast_unsync(struct net_device *to, struct net_device *from)
3051{
3052 netif_tx_lock_bh(from);
3053 netif_tx_lock_bh(to);
3054
3055 __dev_addr_unsync(&to->uc_list, &to->uc_count,
3056 &from->uc_list, &from->uc_count);
3057 __dev_set_rx_mode(to);
3058
3059 netif_tx_unlock_bh(to);
3060 netif_tx_unlock_bh(from);
3061}
3062EXPORT_SYMBOL(dev_unicast_unsync);
3063
Denis Cheng12972622007-07-18 02:12:56 -07003064static void __dev_addr_discard(struct dev_addr_list **list)
3065{
3066 struct dev_addr_list *tmp;
3067
3068 while (*list != NULL) {
3069 tmp = *list;
3070 *list = tmp->next;
3071 if (tmp->da_users > tmp->da_gusers)
3072 printk("__dev_addr_discard: address leakage! "
3073 "da_users=%d\n", tmp->da_users);
3074 kfree(tmp);
3075 }
3076}
3077
Denis Cheng26cc2522007-07-18 02:12:03 -07003078static void dev_addr_discard(struct net_device *dev)
Patrick McHardy4417da62007-06-27 01:28:10 -07003079{
3080 netif_tx_lock_bh(dev);
Denis Cheng26cc2522007-07-18 02:12:03 -07003081
Patrick McHardy4417da62007-06-27 01:28:10 -07003082 __dev_addr_discard(&dev->uc_list);
3083 dev->uc_count = 0;
Patrick McHardy4417da62007-06-27 01:28:10 -07003084
Denis Cheng456ad752007-07-18 02:10:54 -07003085 __dev_addr_discard(&dev->mc_list);
3086 dev->mc_count = 0;
Denis Cheng26cc2522007-07-18 02:12:03 -07003087
Denis Cheng456ad752007-07-18 02:10:54 -07003088 netif_tx_unlock_bh(dev);
3089}
3090
Linus Torvalds1da177e2005-04-16 15:20:36 -07003091unsigned dev_get_flags(const struct net_device *dev)
3092{
3093 unsigned flags;
3094
3095 flags = (dev->flags & ~(IFF_PROMISC |
3096 IFF_ALLMULTI |
Stefan Rompfb00055a2006-03-20 17:09:11 -08003097 IFF_RUNNING |
3098 IFF_LOWER_UP |
3099 IFF_DORMANT)) |
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100 (dev->gflags & (IFF_PROMISC |
3101 IFF_ALLMULTI));
3102
Stefan Rompfb00055a2006-03-20 17:09:11 -08003103 if (netif_running(dev)) {
3104 if (netif_oper_up(dev))
3105 flags |= IFF_RUNNING;
3106 if (netif_carrier_ok(dev))
3107 flags |= IFF_LOWER_UP;
3108 if (netif_dormant(dev))
3109 flags |= IFF_DORMANT;
3110 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003111
3112 return flags;
3113}
3114
3115int dev_change_flags(struct net_device *dev, unsigned flags)
3116{
Thomas Graf7c355f52007-06-05 16:03:03 -07003117 int ret, changes;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118 int old_flags = dev->flags;
3119
Patrick McHardy24023452007-07-14 18:51:31 -07003120 ASSERT_RTNL();
3121
Linus Torvalds1da177e2005-04-16 15:20:36 -07003122 /*
3123 * Set the flags on our device.
3124 */
3125
3126 dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
3127 IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
3128 IFF_AUTOMEDIA)) |
3129 (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
3130 IFF_ALLMULTI));
3131
3132 /*
3133 * Load in the correct multicast list now the flags have changed.
3134 */
3135
Patrick McHardy24023452007-07-14 18:51:31 -07003136 if (dev->change_rx_flags && (dev->flags ^ flags) & IFF_MULTICAST)
3137 dev->change_rx_flags(dev, IFF_MULTICAST);
3138
Patrick McHardy4417da62007-06-27 01:28:10 -07003139 dev_set_rx_mode(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003140
3141 /*
3142 * Have we downed the interface. We handle IFF_UP ourselves
3143 * according to user attempts to set it, rather than blindly
3144 * setting it.
3145 */
3146
3147 ret = 0;
3148 if ((old_flags ^ flags) & IFF_UP) { /* Bit is different ? */
3149 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
3150
3151 if (!ret)
Patrick McHardy4417da62007-06-27 01:28:10 -07003152 dev_set_rx_mode(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003153 }
3154
3155 if (dev->flags & IFF_UP &&
3156 ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
3157 IFF_VOLATILE)))
Pavel Emelyanov056925a2007-09-16 15:42:43 -07003158 call_netdevice_notifiers(NETDEV_CHANGE, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003159
3160 if ((flags ^ dev->gflags) & IFF_PROMISC) {
3161 int inc = (flags & IFF_PROMISC) ? +1 : -1;
3162 dev->gflags ^= IFF_PROMISC;
3163 dev_set_promiscuity(dev, inc);
3164 }
3165
3166 /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
3167 is important. Some (broken) drivers set IFF_PROMISC, when
3168 IFF_ALLMULTI is requested not asking us and not reporting.
3169 */
3170 if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
3171 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
3172 dev->gflags ^= IFF_ALLMULTI;
3173 dev_set_allmulti(dev, inc);
3174 }
3175
Thomas Graf7c355f52007-06-05 16:03:03 -07003176 /* Exclude state transition flags, already notified */
3177 changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
3178 if (changes)
3179 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003180
3181 return ret;
3182}
3183
3184int dev_set_mtu(struct net_device *dev, int new_mtu)
3185{
3186 int err;
3187
3188 if (new_mtu == dev->mtu)
3189 return 0;
3190
3191 /* MTU must be positive. */
3192 if (new_mtu < 0)
3193 return -EINVAL;
3194
3195 if (!netif_device_present(dev))
3196 return -ENODEV;
3197
3198 err = 0;
3199 if (dev->change_mtu)
3200 err = dev->change_mtu(dev, new_mtu);
3201 else
3202 dev->mtu = new_mtu;
3203 if (!err && dev->flags & IFF_UP)
Pavel Emelyanov056925a2007-09-16 15:42:43 -07003204 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003205 return err;
3206}
3207
3208int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
3209{
3210 int err;
3211
3212 if (!dev->set_mac_address)
3213 return -EOPNOTSUPP;
3214 if (sa->sa_family != dev->type)
3215 return -EINVAL;
3216 if (!netif_device_present(dev))
3217 return -ENODEV;
3218 err = dev->set_mac_address(dev, sa);
3219 if (!err)
Pavel Emelyanov056925a2007-09-16 15:42:43 -07003220 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003221 return err;
3222}
3223
3224/*
Jeff Garzik14e3e072007-10-08 00:06:32 -07003225 * Perform the SIOCxIFxxx calls, inside read_lock(dev_base_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003226 */
Jeff Garzik14e3e072007-10-08 00:06:32 -07003227static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003228{
3229 int err;
Eric W. Biederman881d9662007-09-17 11:56:21 -07003230 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003231
3232 if (!dev)
3233 return -ENODEV;
3234
3235 switch (cmd) {
3236 case SIOCGIFFLAGS: /* Get interface flags */
3237 ifr->ifr_flags = dev_get_flags(dev);
3238 return 0;
3239
Linus Torvalds1da177e2005-04-16 15:20:36 -07003240 case SIOCGIFMETRIC: /* Get the metric on the interface
3241 (currently unused) */
3242 ifr->ifr_metric = 0;
3243 return 0;
3244
Linus Torvalds1da177e2005-04-16 15:20:36 -07003245 case SIOCGIFMTU: /* Get the MTU of a device */
3246 ifr->ifr_mtu = dev->mtu;
3247 return 0;
3248
Linus Torvalds1da177e2005-04-16 15:20:36 -07003249 case SIOCGIFHWADDR:
3250 if (!dev->addr_len)
3251 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
3252 else
3253 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
3254 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3255 ifr->ifr_hwaddr.sa_family = dev->type;
3256 return 0;
3257
Jeff Garzik14e3e072007-10-08 00:06:32 -07003258 case SIOCGIFSLAVE:
3259 err = -EINVAL;
3260 break;
3261
3262 case SIOCGIFMAP:
3263 ifr->ifr_map.mem_start = dev->mem_start;
3264 ifr->ifr_map.mem_end = dev->mem_end;
3265 ifr->ifr_map.base_addr = dev->base_addr;
3266 ifr->ifr_map.irq = dev->irq;
3267 ifr->ifr_map.dma = dev->dma;
3268 ifr->ifr_map.port = dev->if_port;
3269 return 0;
3270
3271 case SIOCGIFINDEX:
3272 ifr->ifr_ifindex = dev->ifindex;
3273 return 0;
3274
3275 case SIOCGIFTXQLEN:
3276 ifr->ifr_qlen = dev->tx_queue_len;
3277 return 0;
3278
3279 default:
3280 /* dev_ioctl() should ensure this case
3281 * is never reached
3282 */
3283 WARN_ON(1);
3284 err = -EINVAL;
3285 break;
3286
3287 }
3288 return err;
3289}
3290
3291/*
3292 * Perform the SIOCxIFxxx calls, inside rtnl_lock()
3293 */
3294static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
3295{
3296 int err;
3297 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3298
3299 if (!dev)
3300 return -ENODEV;
3301
3302 switch (cmd) {
3303 case SIOCSIFFLAGS: /* Set interface flags */
3304 return dev_change_flags(dev, ifr->ifr_flags);
3305
3306 case SIOCSIFMETRIC: /* Set the metric on the interface
3307 (currently unused) */
3308 return -EOPNOTSUPP;
3309
3310 case SIOCSIFMTU: /* Set the MTU of a device */
3311 return dev_set_mtu(dev, ifr->ifr_mtu);
3312
Linus Torvalds1da177e2005-04-16 15:20:36 -07003313 case SIOCSIFHWADDR:
3314 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
3315
3316 case SIOCSIFHWBROADCAST:
3317 if (ifr->ifr_hwaddr.sa_family != dev->type)
3318 return -EINVAL;
3319 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
3320 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
Pavel Emelyanov056925a2007-09-16 15:42:43 -07003321 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003322 return 0;
3323
Linus Torvalds1da177e2005-04-16 15:20:36 -07003324 case SIOCSIFMAP:
3325 if (dev->set_config) {
3326 if (!netif_device_present(dev))
3327 return -ENODEV;
3328 return dev->set_config(dev, &ifr->ifr_map);
3329 }
3330 return -EOPNOTSUPP;
3331
3332 case SIOCADDMULTI:
Patrick McHardy61ee6bd2008-03-26 02:12:11 -07003333 if ((!dev->set_multicast_list && !dev->set_rx_mode) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07003334 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3335 return -EINVAL;
3336 if (!netif_device_present(dev))
3337 return -ENODEV;
3338 return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
3339 dev->addr_len, 1);
3340
3341 case SIOCDELMULTI:
Patrick McHardy61ee6bd2008-03-26 02:12:11 -07003342 if ((!dev->set_multicast_list && !dev->set_rx_mode) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07003343 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3344 return -EINVAL;
3345 if (!netif_device_present(dev))
3346 return -ENODEV;
3347 return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
3348 dev->addr_len, 1);
3349
Linus Torvalds1da177e2005-04-16 15:20:36 -07003350 case SIOCSIFTXQLEN:
3351 if (ifr->ifr_qlen < 0)
3352 return -EINVAL;
3353 dev->tx_queue_len = ifr->ifr_qlen;
3354 return 0;
3355
3356 case SIOCSIFNAME:
3357 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
3358 return dev_change_name(dev, ifr->ifr_newname);
3359
3360 /*
3361 * Unknown or private ioctl
3362 */
3363
3364 default:
3365 if ((cmd >= SIOCDEVPRIVATE &&
3366 cmd <= SIOCDEVPRIVATE + 15) ||
3367 cmd == SIOCBONDENSLAVE ||
3368 cmd == SIOCBONDRELEASE ||
3369 cmd == SIOCBONDSETHWADDR ||
3370 cmd == SIOCBONDSLAVEINFOQUERY ||
3371 cmd == SIOCBONDINFOQUERY ||
3372 cmd == SIOCBONDCHANGEACTIVE ||
3373 cmd == SIOCGMIIPHY ||
3374 cmd == SIOCGMIIREG ||
3375 cmd == SIOCSMIIREG ||
3376 cmd == SIOCBRADDIF ||
3377 cmd == SIOCBRDELIF ||
3378 cmd == SIOCWANDEV) {
3379 err = -EOPNOTSUPP;
3380 if (dev->do_ioctl) {
3381 if (netif_device_present(dev))
3382 err = dev->do_ioctl(dev, ifr,
3383 cmd);
3384 else
3385 err = -ENODEV;
3386 }
3387 } else
3388 err = -EINVAL;
3389
3390 }
3391 return err;
3392}
3393
3394/*
3395 * This function handles all "interface"-type I/O control requests. The actual
3396 * 'doing' part of this is dev_ifsioc above.
3397 */
3398
3399/**
3400 * dev_ioctl - network device ioctl
Randy Dunlapc4ea43c2007-10-12 21:17:49 -07003401 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -07003402 * @cmd: command to issue
3403 * @arg: pointer to a struct ifreq in user space
3404 *
3405 * Issue ioctl functions to devices. This is normally called by the
3406 * user space syscall interfaces but can sometimes be useful for
3407 * other purposes. The return value is the return from the syscall if
3408 * positive or a negative errno code on error.
3409 */
3410
Eric W. Biederman881d9662007-09-17 11:56:21 -07003411int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003412{
3413 struct ifreq ifr;
3414 int ret;
3415 char *colon;
3416
3417 /* One special case: SIOCGIFCONF takes ifconf argument
3418 and requires shared lock, because it sleeps writing
3419 to user space.
3420 */
3421
3422 if (cmd == SIOCGIFCONF) {
Stephen Hemminger6756ae42006-03-20 22:23:58 -08003423 rtnl_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -07003424 ret = dev_ifconf(net, (char __user *) arg);
Stephen Hemminger6756ae42006-03-20 22:23:58 -08003425 rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003426 return ret;
3427 }
3428 if (cmd == SIOCGIFNAME)
Eric W. Biederman881d9662007-09-17 11:56:21 -07003429 return dev_ifname(net, (struct ifreq __user *)arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003430
3431 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
3432 return -EFAULT;
3433
3434 ifr.ifr_name[IFNAMSIZ-1] = 0;
3435
3436 colon = strchr(ifr.ifr_name, ':');
3437 if (colon)
3438 *colon = 0;
3439
3440 /*
3441 * See which interface the caller is talking about.
3442 */
3443
3444 switch (cmd) {
3445 /*
3446 * These ioctl calls:
3447 * - can be done by all.
3448 * - atomic and do not require locking.
3449 * - return a value
3450 */
3451 case SIOCGIFFLAGS:
3452 case SIOCGIFMETRIC:
3453 case SIOCGIFMTU:
3454 case SIOCGIFHWADDR:
3455 case SIOCGIFSLAVE:
3456 case SIOCGIFMAP:
3457 case SIOCGIFINDEX:
3458 case SIOCGIFTXQLEN:
Eric W. Biederman881d9662007-09-17 11:56:21 -07003459 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003460 read_lock(&dev_base_lock);
Jeff Garzik14e3e072007-10-08 00:06:32 -07003461 ret = dev_ifsioc_locked(net, &ifr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462 read_unlock(&dev_base_lock);
3463 if (!ret) {
3464 if (colon)
3465 *colon = ':';
3466 if (copy_to_user(arg, &ifr,
3467 sizeof(struct ifreq)))
3468 ret = -EFAULT;
3469 }
3470 return ret;
3471
3472 case SIOCETHTOOL:
Eric W. Biederman881d9662007-09-17 11:56:21 -07003473 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003474 rtnl_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -07003475 ret = dev_ethtool(net, &ifr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003476 rtnl_unlock();
3477 if (!ret) {
3478 if (colon)
3479 *colon = ':';
3480 if (copy_to_user(arg, &ifr,
3481 sizeof(struct ifreq)))
3482 ret = -EFAULT;
3483 }
3484 return ret;
3485
3486 /*
3487 * These ioctl calls:
3488 * - require superuser power.
3489 * - require strict serialization.
3490 * - return a value
3491 */
3492 case SIOCGMIIPHY:
3493 case SIOCGMIIREG:
3494 case SIOCSIFNAME:
3495 if (!capable(CAP_NET_ADMIN))
3496 return -EPERM;
Eric W. Biederman881d9662007-09-17 11:56:21 -07003497 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003498 rtnl_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -07003499 ret = dev_ifsioc(net, &ifr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003500 rtnl_unlock();
3501 if (!ret) {
3502 if (colon)
3503 *colon = ':';
3504 if (copy_to_user(arg, &ifr,
3505 sizeof(struct ifreq)))
3506 ret = -EFAULT;
3507 }
3508 return ret;
3509
3510 /*
3511 * These ioctl calls:
3512 * - require superuser power.
3513 * - require strict serialization.
3514 * - do not return a value
3515 */
3516 case SIOCSIFFLAGS:
3517 case SIOCSIFMETRIC:
3518 case SIOCSIFMTU:
3519 case SIOCSIFMAP:
3520 case SIOCSIFHWADDR:
3521 case SIOCSIFSLAVE:
3522 case SIOCADDMULTI:
3523 case SIOCDELMULTI:
3524 case SIOCSIFHWBROADCAST:
3525 case SIOCSIFTXQLEN:
3526 case SIOCSMIIREG:
3527 case SIOCBONDENSLAVE:
3528 case SIOCBONDRELEASE:
3529 case SIOCBONDSETHWADDR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003530 case SIOCBONDCHANGEACTIVE:
3531 case SIOCBRADDIF:
3532 case SIOCBRDELIF:
3533 if (!capable(CAP_NET_ADMIN))
3534 return -EPERM;
Thomas Grafcabcac02006-01-24 12:46:33 -08003535 /* fall through */
3536 case SIOCBONDSLAVEINFOQUERY:
3537 case SIOCBONDINFOQUERY:
Eric W. Biederman881d9662007-09-17 11:56:21 -07003538 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003539 rtnl_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -07003540 ret = dev_ifsioc(net, &ifr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003541 rtnl_unlock();
3542 return ret;
3543
3544 case SIOCGIFMEM:
3545 /* Get the per device memory space. We can add this but
3546 * currently do not support it */
3547 case SIOCSIFMEM:
3548 /* Set the per device memory buffer space.
3549 * Not applicable in our case */
3550 case SIOCSIFLINK:
3551 return -EINVAL;
3552
3553 /*
3554 * Unknown or private ioctl.
3555 */
3556 default:
3557 if (cmd == SIOCWANDEV ||
3558 (cmd >= SIOCDEVPRIVATE &&
3559 cmd <= SIOCDEVPRIVATE + 15)) {
Eric W. Biederman881d9662007-09-17 11:56:21 -07003560 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003561 rtnl_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -07003562 ret = dev_ifsioc(net, &ifr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003563 rtnl_unlock();
3564 if (!ret && copy_to_user(arg, &ifr,
3565 sizeof(struct ifreq)))
3566 ret = -EFAULT;
3567 return ret;
3568 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003569 /* Take care of Wireless Extensions */
Johannes Berg295f4a12007-04-26 20:43:56 -07003570 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
Eric W. Biederman881d9662007-09-17 11:56:21 -07003571 return wext_handle_ioctl(net, &ifr, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003572 return -EINVAL;
3573 }
3574}
3575
3576
3577/**
3578 * dev_new_index - allocate an ifindex
Randy Dunlapc4ea43c2007-10-12 21:17:49 -07003579 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -07003580 *
3581 * Returns a suitable unique value for a new device interface
3582 * number. The caller must hold the rtnl semaphore or the
3583 * dev_base_lock to be sure it remains unique.
3584 */
Eric W. Biederman881d9662007-09-17 11:56:21 -07003585static int dev_new_index(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003586{
3587 static int ifindex;
3588 for (;;) {
3589 if (++ifindex <= 0)
3590 ifindex = 1;
Eric W. Biederman881d9662007-09-17 11:56:21 -07003591 if (!__dev_get_by_index(net, ifindex))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003592 return ifindex;
3593 }
3594}
3595
Linus Torvalds1da177e2005-04-16 15:20:36 -07003596/* Delayed registration/unregisteration */
3597static DEFINE_SPINLOCK(net_todo_list_lock);
Denis Cheng3b5b34f2007-12-07 00:49:17 -08003598static LIST_HEAD(net_todo_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003599
Stephen Hemminger6f05f622007-03-08 20:46:03 -08003600static void net_set_todo(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003601{
3602 spin_lock(&net_todo_list_lock);
3603 list_add_tail(&dev->todo_list, &net_todo_list);
3604 spin_unlock(&net_todo_list_lock);
3605}
3606
Daniel Lezcano93ee31f2007-10-30 15:38:18 -07003607static void rollback_registered(struct net_device *dev)
3608{
3609 BUG_ON(dev_boot_phase);
3610 ASSERT_RTNL();
3611
3612 /* Some devices call without registering for initialization unwind. */
3613 if (dev->reg_state == NETREG_UNINITIALIZED) {
3614 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3615 "was registered\n", dev->name, dev);
3616
3617 WARN_ON(1);
3618 return;
3619 }
3620
3621 BUG_ON(dev->reg_state != NETREG_REGISTERED);
3622
3623 /* If device is running, close it first. */
3624 dev_close(dev);
3625
3626 /* And unlink it from device chain. */
3627 unlist_netdevice(dev);
3628
3629 dev->reg_state = NETREG_UNREGISTERING;
3630
3631 synchronize_net();
3632
3633 /* Shutdown queueing discipline. */
3634 dev_shutdown(dev);
3635
3636
3637 /* Notify protocols, that we are about to destroy
3638 this device. They should clean all the things.
3639 */
3640 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
3641
3642 /*
3643 * Flush the unicast and multicast chains
3644 */
3645 dev_addr_discard(dev);
3646
3647 if (dev->uninit)
3648 dev->uninit(dev);
3649
3650 /* Notifier chain MUST detach us from master device. */
3651 BUG_TRAP(!dev->master);
3652
3653 /* Remove entries from kobject tree */
3654 netdev_unregister_kobject(dev);
3655
3656 synchronize_net();
3657
3658 dev_put(dev);
3659}
3660
Linus Torvalds1da177e2005-04-16 15:20:36 -07003661/**
3662 * register_netdevice - register a network device
3663 * @dev: device to register
3664 *
3665 * Take a completed network device structure and add it to the kernel
3666 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3667 * chain. 0 is returned on success. A negative errno code is returned
3668 * on a failure to set up the device, or if the name is a duplicate.
3669 *
3670 * Callers must hold the rtnl semaphore. You may want
3671 * register_netdev() instead of this.
3672 *
3673 * BUGS:
3674 * The locking appears insufficient to guarantee two parallel registers
3675 * will not get the same name.
3676 */
3677
3678int register_netdevice(struct net_device *dev)
3679{
3680 struct hlist_head *head;
3681 struct hlist_node *p;
3682 int ret;
Eric W. Biederman881d9662007-09-17 11:56:21 -07003683 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003684
3685 BUG_ON(dev_boot_phase);
3686 ASSERT_RTNL();
3687
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003688 might_sleep();
3689
Linus Torvalds1da177e2005-04-16 15:20:36 -07003690 /* When net_device's are persistent, this will be fatal. */
3691 BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09003692 BUG_ON(!dev_net(dev));
3693 net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003694
3695 spin_lock_init(&dev->queue_lock);
Herbert Xu932ff272006-06-09 12:20:56 -07003696 spin_lock_init(&dev->_xmit_lock);
Jarek Poplawski723e98b72007-05-15 22:46:18 -07003697 netdev_set_lockdep_class(&dev->_xmit_lock, dev->type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003698 dev->xmit_lock_owner = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003699 spin_lock_init(&dev->ingress_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003700
Linus Torvalds1da177e2005-04-16 15:20:36 -07003701 dev->iflink = -1;
3702
3703 /* Init, if this function is available */
3704 if (dev->init) {
3705 ret = dev->init(dev);
3706 if (ret) {
3707 if (ret > 0)
3708 ret = -EIO;
Adrian Bunk90833aa2006-11-13 16:02:22 -08003709 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003710 }
3711 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003712
Linus Torvalds1da177e2005-04-16 15:20:36 -07003713 if (!dev_valid_name(dev->name)) {
3714 ret = -EINVAL;
Herbert Xu7ce1b0e2007-07-30 16:29:40 -07003715 goto err_uninit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003716 }
3717
Eric W. Biederman881d9662007-09-17 11:56:21 -07003718 dev->ifindex = dev_new_index(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003719 if (dev->iflink == -1)
3720 dev->iflink = dev->ifindex;
3721
3722 /* Check for existence of name */
Eric W. Biederman881d9662007-09-17 11:56:21 -07003723 head = dev_name_hash(net, dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003724 hlist_for_each(p, head) {
3725 struct net_device *d
3726 = hlist_entry(p, struct net_device, name_hlist);
3727 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
3728 ret = -EEXIST;
Herbert Xu7ce1b0e2007-07-30 16:29:40 -07003729 goto err_uninit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003730 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003731 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003732
Stephen Hemmingerd212f872007-06-27 00:47:37 -07003733 /* Fix illegal checksum combinations */
3734 if ((dev->features & NETIF_F_HW_CSUM) &&
3735 (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3736 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
3737 dev->name);
3738 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
3739 }
3740
3741 if ((dev->features & NETIF_F_NO_CSUM) &&
3742 (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
3743 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
3744 dev->name);
3745 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
3746 }
3747
3748
Linus Torvalds1da177e2005-04-16 15:20:36 -07003749 /* Fix illegal SG+CSUM combinations. */
3750 if ((dev->features & NETIF_F_SG) &&
Herbert Xu8648b302006-06-17 22:06:05 -07003751 !(dev->features & NETIF_F_ALL_CSUM)) {
Stephen Hemminger5a8da022006-07-07 16:54:05 -07003752 printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no checksum feature.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003753 dev->name);
3754 dev->features &= ~NETIF_F_SG;
3755 }
3756
3757 /* TSO requires that SG is present as well. */
3758 if ((dev->features & NETIF_F_TSO) &&
3759 !(dev->features & NETIF_F_SG)) {
Stephen Hemminger5a8da022006-07-07 16:54:05 -07003760 printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no SG feature.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003761 dev->name);
3762 dev->features &= ~NETIF_F_TSO;
3763 }
Ananda Rajue89e9cf2005-10-18 15:46:41 -07003764 if (dev->features & NETIF_F_UFO) {
3765 if (!(dev->features & NETIF_F_HW_CSUM)) {
3766 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3767 "NETIF_F_HW_CSUM feature.\n",
3768 dev->name);
3769 dev->features &= ~NETIF_F_UFO;
3770 }
3771 if (!(dev->features & NETIF_F_SG)) {
3772 printk(KERN_ERR "%s: Dropping NETIF_F_UFO since no "
3773 "NETIF_F_SG feature.\n",
3774 dev->name);
3775 dev->features &= ~NETIF_F_UFO;
3776 }
3777 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003778
Eric W. Biederman8b41d182007-09-26 22:02:53 -07003779 ret = netdev_register_kobject(dev);
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003780 if (ret)
Herbert Xu7ce1b0e2007-07-30 16:29:40 -07003781 goto err_uninit;
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003782 dev->reg_state = NETREG_REGISTERED;
3783
Linus Torvalds1da177e2005-04-16 15:20:36 -07003784 /*
3785 * Default initial state at registry is that the
3786 * device is present.
3787 */
3788
3789 set_bit(__LINK_STATE_PRESENT, &dev->state);
3790
Linus Torvalds1da177e2005-04-16 15:20:36 -07003791 dev_init_scheduler(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003792 dev_hold(dev);
Eric W. Biedermance286d32007-09-12 13:53:49 +02003793 list_netdevice(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003794
3795 /* Notify protocols, that a new device appeared. */
Pavel Emelyanov056925a2007-09-16 15:42:43 -07003796 ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
Herbert Xufcc5a032007-07-30 17:03:38 -07003797 ret = notifier_to_errno(ret);
Daniel Lezcano93ee31f2007-10-30 15:38:18 -07003798 if (ret) {
3799 rollback_registered(dev);
3800 dev->reg_state = NETREG_UNREGISTERED;
3801 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003802
3803out:
3804 return ret;
Herbert Xu7ce1b0e2007-07-30 16:29:40 -07003805
3806err_uninit:
3807 if (dev->uninit)
3808 dev->uninit(dev);
3809 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003810}
3811
3812/**
3813 * register_netdev - register a network device
3814 * @dev: device to register
3815 *
3816 * Take a completed network device structure and add it to the kernel
3817 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
3818 * chain. 0 is returned on success. A negative errno code is returned
3819 * on a failure to set up the device, or if the name is a duplicate.
3820 *
Borislav Petkov38b4da382007-04-20 22:14:10 -07003821 * This is a wrapper around register_netdevice that takes the rtnl semaphore
Linus Torvalds1da177e2005-04-16 15:20:36 -07003822 * and expands the device name if you passed a format string to
3823 * alloc_netdev.
3824 */
3825int register_netdev(struct net_device *dev)
3826{
3827 int err;
3828
3829 rtnl_lock();
3830
3831 /*
3832 * If the name is a format string the caller wants us to do a
3833 * name allocation.
3834 */
3835 if (strchr(dev->name, '%')) {
3836 err = dev_alloc_name(dev, dev->name);
3837 if (err < 0)
3838 goto out;
3839 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003840
Linus Torvalds1da177e2005-04-16 15:20:36 -07003841 err = register_netdevice(dev);
3842out:
3843 rtnl_unlock();
3844 return err;
3845}
3846EXPORT_SYMBOL(register_netdev);
3847
3848/*
3849 * netdev_wait_allrefs - wait until all references are gone.
3850 *
3851 * This is called when unregistering network devices.
3852 *
3853 * Any protocol or device that holds a reference should register
3854 * for netdevice notification, and cleanup and put back the
3855 * reference if they receive an UNREGISTER event.
3856 * We can get stuck here if buggy protocols don't correctly
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003857 * call dev_put.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003858 */
3859static void netdev_wait_allrefs(struct net_device *dev)
3860{
3861 unsigned long rebroadcast_time, warning_time;
3862
3863 rebroadcast_time = warning_time = jiffies;
3864 while (atomic_read(&dev->refcnt) != 0) {
3865 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
Stephen Hemminger6756ae42006-03-20 22:23:58 -08003866 rtnl_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003867
3868 /* Rebroadcast unregister notification */
Pavel Emelyanov056925a2007-09-16 15:42:43 -07003869 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003870
3871 if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
3872 &dev->state)) {
3873 /* We must not have linkwatch events
3874 * pending on unregister. If this
3875 * happens, we simply run the queue
3876 * unscheduled, resulting in a noop
3877 * for this device.
3878 */
3879 linkwatch_run_queue();
3880 }
3881
Stephen Hemminger6756ae42006-03-20 22:23:58 -08003882 __rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003883
3884 rebroadcast_time = jiffies;
3885 }
3886
3887 msleep(250);
3888
3889 if (time_after(jiffies, warning_time + 10 * HZ)) {
3890 printk(KERN_EMERG "unregister_netdevice: "
3891 "waiting for %s to become free. Usage "
3892 "count = %d\n",
3893 dev->name, atomic_read(&dev->refcnt));
3894 warning_time = jiffies;
3895 }
3896 }
3897}
3898
3899/* The sequence is:
3900 *
3901 * rtnl_lock();
3902 * ...
3903 * register_netdevice(x1);
3904 * register_netdevice(x2);
3905 * ...
3906 * unregister_netdevice(y1);
3907 * unregister_netdevice(y2);
3908 * ...
3909 * rtnl_unlock();
3910 * free_netdev(y1);
3911 * free_netdev(y2);
3912 *
3913 * We are invoked by rtnl_unlock() after it drops the semaphore.
3914 * This allows us to deal with problems:
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003915 * 1) We can delete sysfs objects which invoke hotplug
Linus Torvalds1da177e2005-04-16 15:20:36 -07003916 * without deadlocking with linkwatch via keventd.
3917 * 2) Since we run with the RTNL semaphore not held, we can sleep
3918 * safely in order to wait for the netdev refcnt to drop to zero.
3919 */
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -08003920static DEFINE_MUTEX(net_todo_run_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003921void netdev_run_todo(void)
3922{
Oleg Nesterov626ab0e2006-06-23 02:05:55 -07003923 struct list_head list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003924
3925 /* Need to guard against multiple cpu's getting out of order. */
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -08003926 mutex_lock(&net_todo_run_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003927
3928 /* Not safe to do outside the semaphore. We must not return
3929 * until all unregister events invoked by the local processor
3930 * have been completed (either by this todo run, or one on
3931 * another cpu).
3932 */
3933 if (list_empty(&net_todo_list))
3934 goto out;
3935
3936 /* Snapshot list, allow later requests */
3937 spin_lock(&net_todo_list_lock);
Oleg Nesterov626ab0e2006-06-23 02:05:55 -07003938 list_replace_init(&net_todo_list, &list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003939 spin_unlock(&net_todo_list_lock);
Oleg Nesterov626ab0e2006-06-23 02:05:55 -07003940
Linus Torvalds1da177e2005-04-16 15:20:36 -07003941 while (!list_empty(&list)) {
3942 struct net_device *dev
3943 = list_entry(list.next, struct net_device, todo_list);
3944 list_del(&dev->todo_list);
3945
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003946 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003947 printk(KERN_ERR "network todo '%s' but state %d\n",
3948 dev->name, dev->reg_state);
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003949 dump_stack();
3950 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003951 }
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003952
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003953 dev->reg_state = NETREG_UNREGISTERED;
3954
3955 netdev_wait_allrefs(dev);
3956
3957 /* paranoia */
3958 BUG_ON(atomic_read(&dev->refcnt));
3959 BUG_TRAP(!dev->ip_ptr);
3960 BUG_TRAP(!dev->ip6_ptr);
3961 BUG_TRAP(!dev->dn_ptr);
3962
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07003963 if (dev->destructor)
3964 dev->destructor(dev);
Stephen Hemminger9093bbb2007-05-19 15:39:25 -07003965
3966 /* Free network device */
3967 kobject_put(&dev->dev.kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003968 }
3969
3970out:
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -08003971 mutex_unlock(&net_todo_run_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003972}
3973
Rusty Russell5a1b5892007-04-28 21:04:03 -07003974static struct net_device_stats *internal_stats(struct net_device *dev)
Rusty Russellc45d2862007-03-28 14:29:08 -07003975{
Rusty Russell5a1b5892007-04-28 21:04:03 -07003976 return &dev->stats;
Rusty Russellc45d2862007-03-28 14:29:08 -07003977}
3978
Linus Torvalds1da177e2005-04-16 15:20:36 -07003979/**
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07003980 * alloc_netdev_mq - allocate network device
Linus Torvalds1da177e2005-04-16 15:20:36 -07003981 * @sizeof_priv: size of private data to allocate space for
3982 * @name: device name format string
3983 * @setup: callback to initialize device
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07003984 * @queue_count: the number of subqueues to allocate
Linus Torvalds1da177e2005-04-16 15:20:36 -07003985 *
3986 * Allocates a struct net_device with private data area for driver use
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07003987 * and performs basic initialization. Also allocates subquue structs
3988 * for each queue on the device at the end of the netdevice.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003989 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07003990struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
3991 void (*setup)(struct net_device *), unsigned int queue_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003992{
3993 void *p;
3994 struct net_device *dev;
3995 int alloc_size;
3996
Stephen Hemmingerb6fe17d2006-08-29 17:06:13 -07003997 BUG_ON(strlen(name) >= sizeof(dev->name));
3998
Alexey Dobriyand1643d22008-04-18 15:43:32 -07003999 alloc_size = sizeof(struct net_device) +
4000 sizeof(struct net_device_subqueue) * (queue_count - 1);
4001 if (sizeof_priv) {
4002 /* ensure 32-byte alignment of private area */
4003 alloc_size = (alloc_size + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
4004 alloc_size += sizeof_priv;
4005 }
4006 /* ensure 32-byte alignment of whole construct */
4007 alloc_size += NETDEV_ALIGN_CONST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004008
Paolo 'Blaisorblade' Giarrusso31380de2006-04-06 22:38:28 -07004009 p = kzalloc(alloc_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004010 if (!p) {
Stephen Hemmingerb6fe17d2006-08-29 17:06:13 -07004011 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004012 return NULL;
4013 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004014
4015 dev = (struct net_device *)
4016 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
4017 dev->padded = (char *)dev - (char *)p;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09004018 dev_net_set(dev, &init_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004019
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07004020 if (sizeof_priv) {
4021 dev->priv = ((char *)dev +
4022 ((sizeof(struct net_device) +
4023 (sizeof(struct net_device_subqueue) *
Patrick McHardy31ce72a2007-07-20 19:45:45 -07004024 (queue_count - 1)) + NETDEV_ALIGN_CONST)
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07004025 & ~NETDEV_ALIGN_CONST));
4026 }
4027
4028 dev->egress_subqueue_count = queue_count;
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07004029 dev->gso_max_size = GSO_MAX_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004030
Rusty Russell5a1b5892007-04-28 21:04:03 -07004031 dev->get_stats = internal_stats;
Stephen Hemmingerbea33482007-10-03 16:41:36 -07004032 netpoll_netdev_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004033 setup(dev);
4034 strcpy(dev->name, name);
4035 return dev;
4036}
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07004037EXPORT_SYMBOL(alloc_netdev_mq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004038
4039/**
4040 * free_netdev - free network device
4041 * @dev: device
4042 *
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09004043 * This function does the last stage of destroying an allocated device
4044 * interface. The reference to the device object is released.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004045 * If this is the last reference then it will be freed.
4046 */
4047void free_netdev(struct net_device *dev)
4048{
Denis V. Lunevf3005d72008-04-16 02:02:18 -07004049 release_net(dev_net(dev));
4050
Stephen Hemminger3041a062006-05-26 13:25:24 -07004051 /* Compatibility with error handling in drivers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004052 if (dev->reg_state == NETREG_UNINITIALIZED) {
4053 kfree((char *)dev - dev->padded);
4054 return;
4055 }
4056
4057 BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
4058 dev->reg_state = NETREG_RELEASED;
4059
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07004060 /* will free via device release */
4061 put_device(&dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004062}
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09004063
Linus Torvalds1da177e2005-04-16 15:20:36 -07004064/* Synchronize with packet receive processing. */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09004065void synchronize_net(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004066{
4067 might_sleep();
Paul E. McKenneyfbd568a3e2005-05-01 08:59:04 -07004068 synchronize_rcu();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004069}
4070
4071/**
4072 * unregister_netdevice - remove device from the kernel
4073 * @dev: device
4074 *
4075 * This function shuts down a device interface and removes it
Wang Chend59b54b2007-12-11 02:28:03 -08004076 * from the kernel tables.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004077 *
4078 * Callers must hold the rtnl semaphore. You may want
4079 * unregister_netdev() instead of this.
4080 */
4081
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08004082void unregister_netdevice(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004083{
Herbert Xua6620712007-12-12 19:21:56 -08004084 ASSERT_RTNL();
4085
Daniel Lezcano93ee31f2007-10-30 15:38:18 -07004086 rollback_registered(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004087 /* Finish processing unregister after unlock */
4088 net_set_todo(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004089}
4090
4091/**
4092 * unregister_netdev - remove device from the kernel
4093 * @dev: device
4094 *
4095 * This function shuts down a device interface and removes it
Wang Chend59b54b2007-12-11 02:28:03 -08004096 * from the kernel tables.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004097 *
4098 * This is just a wrapper for unregister_netdevice that takes
4099 * the rtnl semaphore. In general you want to use this and not
4100 * unregister_netdevice.
4101 */
4102void unregister_netdev(struct net_device *dev)
4103{
4104 rtnl_lock();
4105 unregister_netdevice(dev);
4106 rtnl_unlock();
4107}
4108
4109EXPORT_SYMBOL(unregister_netdev);
4110
Eric W. Biedermance286d32007-09-12 13:53:49 +02004111/**
4112 * dev_change_net_namespace - move device to different nethost namespace
4113 * @dev: device
4114 * @net: network namespace
4115 * @pat: If not NULL name pattern to try if the current device name
4116 * is already taken in the destination network namespace.
4117 *
4118 * This function shuts down a device interface and moves it
4119 * to a new network namespace. On success 0 is returned, on
4120 * a failure a netagive errno code is returned.
4121 *
4122 * Callers must hold the rtnl semaphore.
4123 */
4124
4125int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
4126{
4127 char buf[IFNAMSIZ];
4128 const char *destname;
4129 int err;
4130
4131 ASSERT_RTNL();
4132
4133 /* Don't allow namespace local devices to be moved. */
4134 err = -EINVAL;
4135 if (dev->features & NETIF_F_NETNS_LOCAL)
4136 goto out;
4137
4138 /* Ensure the device has been registrered */
4139 err = -EINVAL;
4140 if (dev->reg_state != NETREG_REGISTERED)
4141 goto out;
4142
4143 /* Get out if there is nothing todo */
4144 err = 0;
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09004145 if (net_eq(dev_net(dev), net))
Eric W. Biedermance286d32007-09-12 13:53:49 +02004146 goto out;
4147
4148 /* Pick the destination device name, and ensure
4149 * we can use it in the destination network namespace.
4150 */
4151 err = -EEXIST;
4152 destname = dev->name;
4153 if (__dev_get_by_name(net, destname)) {
4154 /* We get here if we can't use the current device name */
4155 if (!pat)
4156 goto out;
4157 if (!dev_valid_name(pat))
4158 goto out;
4159 if (strchr(pat, '%')) {
4160 if (__dev_alloc_name(net, pat, buf) < 0)
4161 goto out;
4162 destname = buf;
4163 } else
4164 destname = pat;
4165 if (__dev_get_by_name(net, destname))
4166 goto out;
4167 }
4168
4169 /*
4170 * And now a mini version of register_netdevice unregister_netdevice.
4171 */
4172
4173 /* If device is running close it first. */
Pavel Emelyanov9b772652007-10-10 02:49:09 -07004174 dev_close(dev);
Eric W. Biedermance286d32007-09-12 13:53:49 +02004175
4176 /* And unlink it from device chain */
4177 err = -ENODEV;
4178 unlist_netdevice(dev);
4179
4180 synchronize_net();
4181
4182 /* Shutdown queueing discipline. */
4183 dev_shutdown(dev);
4184
4185 /* Notify protocols, that we are about to destroy
4186 this device. They should clean all the things.
4187 */
4188 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4189
4190 /*
4191 * Flush the unicast and multicast chains
4192 */
4193 dev_addr_discard(dev);
4194
4195 /* Actually switch the network namespace */
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09004196 dev_net_set(dev, net);
Eric W. Biedermance286d32007-09-12 13:53:49 +02004197
4198 /* Assign the new device name */
4199 if (destname != dev->name)
4200 strcpy(dev->name, destname);
4201
4202 /* If there is an ifindex conflict assign a new one */
4203 if (__dev_get_by_index(net, dev->ifindex)) {
4204 int iflink = (dev->iflink == dev->ifindex);
4205 dev->ifindex = dev_new_index(net);
4206 if (iflink)
4207 dev->iflink = dev->ifindex;
4208 }
4209
Eric W. Biederman8b41d182007-09-26 22:02:53 -07004210 /* Fixup kobjects */
Eric W. Biedermance286d32007-09-12 13:53:49 +02004211 err = device_rename(&dev->dev, dev->name);
Eric W. Biederman8b41d182007-09-26 22:02:53 -07004212 WARN_ON(err);
Eric W. Biedermance286d32007-09-12 13:53:49 +02004213
4214 /* Add the device back in the hashes */
4215 list_netdevice(dev);
4216
4217 /* Notify protocols, that a new device appeared. */
4218 call_netdevice_notifiers(NETDEV_REGISTER, dev);
4219
4220 synchronize_net();
4221 err = 0;
4222out:
4223 return err;
4224}
4225
Linus Torvalds1da177e2005-04-16 15:20:36 -07004226static int dev_cpu_callback(struct notifier_block *nfb,
4227 unsigned long action,
4228 void *ocpu)
4229{
4230 struct sk_buff **list_skb;
4231 struct net_device **list_net;
4232 struct sk_buff *skb;
4233 unsigned int cpu, oldcpu = (unsigned long)ocpu;
4234 struct softnet_data *sd, *oldsd;
4235
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07004236 if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004237 return NOTIFY_OK;
4238
4239 local_irq_disable();
4240 cpu = smp_processor_id();
4241 sd = &per_cpu(softnet_data, cpu);
4242 oldsd = &per_cpu(softnet_data, oldcpu);
4243
4244 /* Find end of our completion_queue. */
4245 list_skb = &sd->completion_queue;
4246 while (*list_skb)
4247 list_skb = &(*list_skb)->next;
4248 /* Append completion queue from offline CPU. */
4249 *list_skb = oldsd->completion_queue;
4250 oldsd->completion_queue = NULL;
4251
4252 /* Find end of our output_queue. */
4253 list_net = &sd->output_queue;
4254 while (*list_net)
4255 list_net = &(*list_net)->next_sched;
4256 /* Append output queue from offline CPU. */
4257 *list_net = oldsd->output_queue;
4258 oldsd->output_queue = NULL;
4259
4260 raise_softirq_irqoff(NET_TX_SOFTIRQ);
4261 local_irq_enable();
4262
4263 /* Process offline CPU's input_pkt_queue */
4264 while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
4265 netif_rx(skb);
4266
4267 return NOTIFY_OK;
4268}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004269
Chris Leechdb217332006-06-17 21:24:58 -07004270#ifdef CONFIG_NET_DMA
4271/**
Randy Dunlap0ed72ec2007-07-26 00:03:29 -07004272 * net_dma_rebalance - try to maintain one DMA channel per CPU
4273 * @net_dma: DMA client and associated data (lock, channels, channel_mask)
4274 *
4275 * This is called when the number of channels allocated to the net_dma client
4276 * changes. The net_dma client tries to have one DMA channel per CPU.
Chris Leechdb217332006-06-17 21:24:58 -07004277 */
Dan Williamsd379b012007-07-09 11:56:42 -07004278
4279static void net_dma_rebalance(struct net_dma *net_dma)
Chris Leechdb217332006-06-17 21:24:58 -07004280{
Dan Williamsd379b012007-07-09 11:56:42 -07004281 unsigned int cpu, i, n, chan_idx;
Chris Leechdb217332006-06-17 21:24:58 -07004282 struct dma_chan *chan;
4283
Dan Williamsd379b012007-07-09 11:56:42 -07004284 if (cpus_empty(net_dma->channel_mask)) {
Chris Leechdb217332006-06-17 21:24:58 -07004285 for_each_online_cpu(cpu)
Alexey Dobriyan29bbd722006-08-02 15:02:31 -07004286 rcu_assign_pointer(per_cpu(softnet_data, cpu).net_dma, NULL);
Chris Leechdb217332006-06-17 21:24:58 -07004287 return;
4288 }
4289
4290 i = 0;
4291 cpu = first_cpu(cpu_online_map);
4292
Dan Williamsd379b012007-07-09 11:56:42 -07004293 for_each_cpu_mask(chan_idx, net_dma->channel_mask) {
4294 chan = net_dma->channels[chan_idx];
4295
4296 n = ((num_online_cpus() / cpus_weight(net_dma->channel_mask))
4297 + (i < (num_online_cpus() %
4298 cpus_weight(net_dma->channel_mask)) ? 1 : 0));
Chris Leechdb217332006-06-17 21:24:58 -07004299
4300 while(n) {
Alexey Dobriyan29bbd722006-08-02 15:02:31 -07004301 per_cpu(softnet_data, cpu).net_dma = chan;
Chris Leechdb217332006-06-17 21:24:58 -07004302 cpu = next_cpu(cpu, cpu_online_map);
4303 n--;
4304 }
4305 i++;
4306 }
Chris Leechdb217332006-06-17 21:24:58 -07004307}
4308
4309/**
4310 * netdev_dma_event - event callback for the net_dma_client
4311 * @client: should always be net_dma_client
Randy Dunlapf4b8ea72006-06-22 16:00:11 -07004312 * @chan: DMA channel for the event
Randy Dunlap0ed72ec2007-07-26 00:03:29 -07004313 * @state: DMA state to be handled
Chris Leechdb217332006-06-17 21:24:58 -07004314 */
Dan Williamsd379b012007-07-09 11:56:42 -07004315static enum dma_state_client
4316netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
4317 enum dma_state state)
Chris Leechdb217332006-06-17 21:24:58 -07004318{
Dan Williamsd379b012007-07-09 11:56:42 -07004319 int i, found = 0, pos = -1;
4320 struct net_dma *net_dma =
4321 container_of(client, struct net_dma, client);
4322 enum dma_state_client ack = DMA_DUP; /* default: take no action */
4323
4324 spin_lock(&net_dma->lock);
4325 switch (state) {
4326 case DMA_RESOURCE_AVAILABLE:
4327 for (i = 0; i < NR_CPUS; i++)
4328 if (net_dma->channels[i] == chan) {
4329 found = 1;
4330 break;
4331 } else if (net_dma->channels[i] == NULL && pos < 0)
4332 pos = i;
4333
4334 if (!found && pos >= 0) {
4335 ack = DMA_ACK;
4336 net_dma->channels[pos] = chan;
4337 cpu_set(pos, net_dma->channel_mask);
4338 net_dma_rebalance(net_dma);
4339 }
Chris Leechdb217332006-06-17 21:24:58 -07004340 break;
4341 case DMA_RESOURCE_REMOVED:
Dan Williamsd379b012007-07-09 11:56:42 -07004342 for (i = 0; i < NR_CPUS; i++)
4343 if (net_dma->channels[i] == chan) {
4344 found = 1;
4345 pos = i;
4346 break;
4347 }
4348
4349 if (found) {
4350 ack = DMA_ACK;
4351 cpu_clear(pos, net_dma->channel_mask);
4352 net_dma->channels[i] = NULL;
4353 net_dma_rebalance(net_dma);
4354 }
Chris Leechdb217332006-06-17 21:24:58 -07004355 break;
4356 default:
4357 break;
4358 }
Dan Williamsd379b012007-07-09 11:56:42 -07004359 spin_unlock(&net_dma->lock);
4360
4361 return ack;
Chris Leechdb217332006-06-17 21:24:58 -07004362}
4363
4364/**
4365 * netdev_dma_regiser - register the networking subsystem as a DMA client
4366 */
4367static int __init netdev_dma_register(void)
4368{
Dan Williamsd379b012007-07-09 11:56:42 -07004369 spin_lock_init(&net_dma.lock);
4370 dma_cap_set(DMA_MEMCPY, net_dma.client.cap_mask);
4371 dma_async_client_register(&net_dma.client);
4372 dma_async_client_chan_request(&net_dma.client);
Chris Leechdb217332006-06-17 21:24:58 -07004373 return 0;
4374}
4375
4376#else
4377static int __init netdev_dma_register(void) { return -ENODEV; }
4378#endif /* CONFIG_NET_DMA */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004379
Herbert Xu7f353bf2007-08-10 15:47:58 -07004380/**
4381 * netdev_compute_feature - compute conjunction of two feature sets
4382 * @all: first feature set
4383 * @one: second feature set
4384 *
4385 * Computes a new feature set after adding a device with feature set
4386 * @one to the master device with current feature set @all. Returns
4387 * the new feature set.
4388 */
4389int netdev_compute_features(unsigned long all, unsigned long one)
4390{
4391 /* if device needs checksumming, downgrade to hw checksumming */
4392 if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
4393 all ^= NETIF_F_NO_CSUM | NETIF_F_HW_CSUM;
4394
4395 /* if device can't do all checksum, downgrade to ipv4/ipv6 */
4396 if (all & NETIF_F_HW_CSUM && !(one & NETIF_F_HW_CSUM))
4397 all ^= NETIF_F_HW_CSUM
4398 | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
4399
4400 if (one & NETIF_F_GSO)
4401 one |= NETIF_F_GSO_SOFTWARE;
4402 one |= NETIF_F_GSO;
4403
4404 /* If even one device supports robust GSO, enable it for all. */
4405 if (one & NETIF_F_GSO_ROBUST)
4406 all |= NETIF_F_GSO_ROBUST;
4407
4408 all &= one | NETIF_F_LLTX;
4409
4410 if (!(all & NETIF_F_ALL_CSUM))
4411 all &= ~NETIF_F_SG;
4412 if (!(all & NETIF_F_SG))
4413 all &= ~NETIF_F_GSO_MASK;
4414
4415 return all;
4416}
4417EXPORT_SYMBOL(netdev_compute_features);
4418
Pavel Emelyanov30d97d32007-09-16 15:40:33 -07004419static struct hlist_head *netdev_create_hash(void)
4420{
4421 int i;
4422 struct hlist_head *hash;
4423
4424 hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
4425 if (hash != NULL)
4426 for (i = 0; i < NETDEV_HASHENTRIES; i++)
4427 INIT_HLIST_HEAD(&hash[i]);
4428
4429 return hash;
4430}
4431
Eric W. Biederman881d9662007-09-17 11:56:21 -07004432/* Initialize per network namespace state */
Pavel Emelyanov46650792007-10-08 20:38:39 -07004433static int __net_init netdev_init(struct net *net)
Eric W. Biederman881d9662007-09-17 11:56:21 -07004434{
Eric W. Biederman881d9662007-09-17 11:56:21 -07004435 INIT_LIST_HEAD(&net->dev_base_head);
Eric W. Biederman881d9662007-09-17 11:56:21 -07004436
Pavel Emelyanov30d97d32007-09-16 15:40:33 -07004437 net->dev_name_head = netdev_create_hash();
4438 if (net->dev_name_head == NULL)
4439 goto err_name;
Eric W. Biederman881d9662007-09-17 11:56:21 -07004440
Pavel Emelyanov30d97d32007-09-16 15:40:33 -07004441 net->dev_index_head = netdev_create_hash();
4442 if (net->dev_index_head == NULL)
4443 goto err_idx;
Eric W. Biederman881d9662007-09-17 11:56:21 -07004444
4445 return 0;
Pavel Emelyanov30d97d32007-09-16 15:40:33 -07004446
4447err_idx:
4448 kfree(net->dev_name_head);
4449err_name:
4450 return -ENOMEM;
Eric W. Biederman881d9662007-09-17 11:56:21 -07004451}
4452
Pavel Emelyanov46650792007-10-08 20:38:39 -07004453static void __net_exit netdev_exit(struct net *net)
Eric W. Biederman881d9662007-09-17 11:56:21 -07004454{
4455 kfree(net->dev_name_head);
4456 kfree(net->dev_index_head);
4457}
4458
Denis V. Lunev022cbae2007-11-13 03:23:50 -08004459static struct pernet_operations __net_initdata netdev_net_ops = {
Eric W. Biederman881d9662007-09-17 11:56:21 -07004460 .init = netdev_init,
4461 .exit = netdev_exit,
4462};
4463
Pavel Emelyanov46650792007-10-08 20:38:39 -07004464static void __net_exit default_device_exit(struct net *net)
Eric W. Biedermance286d32007-09-12 13:53:49 +02004465{
4466 struct net_device *dev, *next;
4467 /*
4468 * Push all migratable of the network devices back to the
4469 * initial network namespace
4470 */
4471 rtnl_lock();
4472 for_each_netdev_safe(net, dev, next) {
4473 int err;
4474
4475 /* Ignore unmoveable devices (i.e. loopback) */
4476 if (dev->features & NETIF_F_NETNS_LOCAL)
4477 continue;
4478
4479 /* Push remaing network devices to init_net */
4480 err = dev_change_net_namespace(dev, &init_net, "dev%d");
4481 if (err) {
4482 printk(KERN_WARNING "%s: failed to move %s to init_net: %d\n",
4483 __func__, dev->name, err);
4484 unregister_netdevice(dev);
4485 }
4486 }
4487 rtnl_unlock();
4488}
4489
Denis V. Lunev022cbae2007-11-13 03:23:50 -08004490static struct pernet_operations __net_initdata default_device_ops = {
Eric W. Biedermance286d32007-09-12 13:53:49 +02004491 .exit = default_device_exit,
4492};
4493
Linus Torvalds1da177e2005-04-16 15:20:36 -07004494/*
4495 * Initialize the DEV module. At boot time this walks the device list and
4496 * unhooks any devices that fail to initialise (normally hardware not
4497 * present) and leaves us with a valid list of present and active devices.
4498 *
4499 */
4500
4501/*
4502 * This is called single threaded during boot, so no need
4503 * to take the rtnl semaphore.
4504 */
4505static int __init net_dev_init(void)
4506{
4507 int i, rc = -ENOMEM;
4508
4509 BUG_ON(!dev_boot_phase);
4510
Linus Torvalds1da177e2005-04-16 15:20:36 -07004511 if (dev_proc_init())
4512 goto out;
4513
Eric W. Biederman8b41d182007-09-26 22:02:53 -07004514 if (netdev_kobject_init())
Linus Torvalds1da177e2005-04-16 15:20:36 -07004515 goto out;
4516
4517 INIT_LIST_HEAD(&ptype_all);
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +08004518 for (i = 0; i < PTYPE_HASH_SIZE; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004519 INIT_LIST_HEAD(&ptype_base[i]);
4520
Eric W. Biederman881d9662007-09-17 11:56:21 -07004521 if (register_pernet_subsys(&netdev_net_ops))
4522 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004523
Eric W. Biedermance286d32007-09-12 13:53:49 +02004524 if (register_pernet_device(&default_device_ops))
4525 goto out;
4526
Linus Torvalds1da177e2005-04-16 15:20:36 -07004527 /*
4528 * Initialise the packet receive queues.
4529 */
4530
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -07004531 for_each_possible_cpu(i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004532 struct softnet_data *queue;
4533
4534 queue = &per_cpu(softnet_data, i);
4535 skb_queue_head_init(&queue->input_pkt_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004536 queue->completion_queue = NULL;
4537 INIT_LIST_HEAD(&queue->poll_list);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07004538
4539 queue->backlog.poll = process_backlog;
4540 queue->backlog.weight = weight_p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004541 }
4542
Chris Leechdb217332006-06-17 21:24:58 -07004543 netdev_dma_register();
4544
Linus Torvalds1da177e2005-04-16 15:20:36 -07004545 dev_boot_phase = 0;
4546
4547 open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
4548 open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
4549
4550 hotcpu_notifier(dev_cpu_callback, 0);
4551 dst_init();
4552 dev_mcast_init();
4553 rc = 0;
4554out:
4555 return rc;
4556}
4557
4558subsys_initcall(net_dev_init);
4559
4560EXPORT_SYMBOL(__dev_get_by_index);
4561EXPORT_SYMBOL(__dev_get_by_name);
4562EXPORT_SYMBOL(__dev_remove_pack);
Mitch Williamsc2373ee2005-11-09 10:34:45 -08004563EXPORT_SYMBOL(dev_valid_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004564EXPORT_SYMBOL(dev_add_pack);
4565EXPORT_SYMBOL(dev_alloc_name);
4566EXPORT_SYMBOL(dev_close);
4567EXPORT_SYMBOL(dev_get_by_flags);
4568EXPORT_SYMBOL(dev_get_by_index);
4569EXPORT_SYMBOL(dev_get_by_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004570EXPORT_SYMBOL(dev_open);
4571EXPORT_SYMBOL(dev_queue_xmit);
4572EXPORT_SYMBOL(dev_remove_pack);
4573EXPORT_SYMBOL(dev_set_allmulti);
4574EXPORT_SYMBOL(dev_set_promiscuity);
4575EXPORT_SYMBOL(dev_change_flags);
4576EXPORT_SYMBOL(dev_set_mtu);
4577EXPORT_SYMBOL(dev_set_mac_address);
4578EXPORT_SYMBOL(free_netdev);
4579EXPORT_SYMBOL(netdev_boot_setup_check);
4580EXPORT_SYMBOL(netdev_set_master);
4581EXPORT_SYMBOL(netdev_state_change);
4582EXPORT_SYMBOL(netif_receive_skb);
4583EXPORT_SYMBOL(netif_rx);
4584EXPORT_SYMBOL(register_gifconf);
4585EXPORT_SYMBOL(register_netdevice);
4586EXPORT_SYMBOL(register_netdevice_notifier);
4587EXPORT_SYMBOL(skb_checksum_help);
4588EXPORT_SYMBOL(synchronize_net);
4589EXPORT_SYMBOL(unregister_netdevice);
4590EXPORT_SYMBOL(unregister_netdevice_notifier);
4591EXPORT_SYMBOL(net_enable_timestamp);
4592EXPORT_SYMBOL(net_disable_timestamp);
4593EXPORT_SYMBOL(dev_get_flags);
4594
4595#if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
4596EXPORT_SYMBOL(br_handle_frame_hook);
4597EXPORT_SYMBOL(br_fdb_get_hook);
4598EXPORT_SYMBOL(br_fdb_put_hook);
4599#endif
4600
4601#ifdef CONFIG_KMOD
4602EXPORT_SYMBOL(dev_load);
4603#endif
4604
4605EXPORT_PER_CPU_SYMBOL(softnet_data);