linux/net/core/dev.c
<<
>>
Prefs
   1/*
   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
  10 *              Authors:        Ross Biro
  11 *                              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12 *                              Mark Evans, <evansmp@uhura.aston.ac.uk>
  13 *
  14 *      Additional Authors:
  15 *              Florian la Roche <rzsfl@rz.uni-sb.de>
  16 *              Alan Cox <gw4pts@gw4pts.ampr.org>
  17 *              David Hinds <dahinds@users.sourceforge.net>
  18 *              Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
  19 *              Adam Sulmicki <adam@cfar.umd.edu>
  20 *              Pekka Riikonen <priikone@poesidon.pspt.fi>
  21 *
  22 *      Changes:
  23 *              D.J. Barrow     :       Fixed bug where dev->refcnt gets set
  24 *                                      to 2 if register_netdev gets called
  25 *                                      before net_dev_init & also removed a
  26 *                                      few lines of code in the process.
  27 *              Alan Cox        :       device private ioctl copies fields back.
  28 *              Alan Cox        :       Transmit queue code does relevant
  29 *                                      stunts to keep the queue safe.
  30 *              Alan Cox        :       Fixed double lock.
  31 *              Alan Cox        :       Fixed promisc NULL pointer trap
  32 *              ????????        :       Support the full private ioctl range
  33 *              Alan Cox        :       Moved ioctl permission check into
  34 *                                      drivers
  35 *              Tim Kordas      :       SIOCADDMULTI/SIOCDELMULTI
  36 *              Alan Cox        :       100 backlog just doesn't cut it when
  37 *                                      you start doing multicast video 8)
  38 *              Alan Cox        :       Rewrote net_bh and list manager.
  39 *              Alan Cox        :       Fix ETH_P_ALL echoback lengths.
  40 *              Alan Cox        :       Took out transmit every packet pass
  41 *                                      Saved a few bytes in the ioctl handler
  42 *              Alan Cox        :       Network driver sets packet type before
  43 *                                      calling netif_rx. Saves a function
  44 *                                      call a packet.
  45 *              Alan Cox        :       Hashed net_bh()
  46 *              Richard Kooijman:       Timestamp fixes.
  47 *              Alan Cox        :       Wrong field in SIOCGIFDSTADDR
  48 *              Alan Cox        :       Device lock protection.
  49 *              Alan Cox        :       Fixed nasty side effect of device close
  50 *                                      changes.
  51 *              Rudi Cilibrasi  :       Pass the right thing to
  52 *                                      set_mac_address()
  53 *              Dave Miller     :       32bit quantity for the device lock to
  54 *                                      make it work out on a Sparc.
  55 *              Bjorn Ekwall    :       Added KERNELD hack.
  56 *              Alan Cox        :       Cleaned up the backlog initialise.
  57 *              Craig Metz      :       SIOCGIFCONF fix if space for under
  58 *                                      1 device.
  59 *          Thomas Bogendoerfer :       Return ENODEV for dev_open, if there
  60 *                                      is no device open function.
  61 *              Andi Kleen      :       Fix error reporting for SIOCGIFCONF
  62 *          Michael Chastain    :       Fix signed/unsigned for SIOCGIFCONF
  63 *              Cyrus Durgin    :       Cleaned for KMOD
  64 *              Adam Sulmicki   :       Bug Fix : Network Device Unload
  65 *                                      A network device unload needs to purge
  66 *                                      the backlog queue.
  67 *      Paul Rusty Russell      :       SIOCSIFNAME
  68 *              Pekka Riikonen  :       Netdev boot-time settings code
  69 *              Andrew Morton   :       Make unregister_netdevice wait
  70 *                                      indefinitely on dev->refcnt
  71 *              J Hadi Salim    :       - Backlog queue sampling
  72 *                                      - netif_rx() feedback
  73 */
  74
  75#include <asm/uaccess.h>
  76#include <asm/system.h>
  77#include <linux/bitops.h>
  78#include <linux/capability.h>
  79#include <linux/cpu.h>
  80#include <linux/types.h>
  81#include <linux/kernel.h>
  82#include <linux/sched.h>
  83#include <linux/mutex.h>
  84#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/ethtool.h>
  94#include <linux/notifier.h>
  95#include <linux/skbuff.h>
  96#include <net/net_namespace.h>
  97#include <net/sock.h>
  98#include <linux/rtnetlink.h>
  99#include <linux/proc_fs.h>
 100#include <linux/seq_file.h>
 101#include <linux/stat.h>
 102#include <linux/if_bridge.h>
 103#include <linux/if_macvlan.h>
 104#include <net/dst.h>
 105#include <net/pkt_sched.h>
 106#include <net/checksum.h>
 107#include <linux/highmem.h>
 108#include <linux/init.h>
 109#include <linux/kmod.h>
 110#include <linux/module.h>
 111#include <linux/netpoll.h>
 112#include <linux/rcupdate.h>
 113#include <linux/delay.h>
 114#include <net/wext.h>
 115#include <net/iw_handler.h>
 116#include <asm/current.h>
 117#include <linux/audit.h>
 118#include <linux/dmaengine.h>
 119#include <linux/err.h>
 120#include <linux/ctype.h>
 121#include <linux/if_arp.h>
 122#include <linux/if_vlan.h>
 123#include <linux/ip.h>
 124#include <net/ip.h>
 125#include <linux/ipv6.h>
 126#include <linux/in.h>
 127#include <linux/jhash.h>
 128#include <linux/random.h>
 129
 130#include "net-sysfs.h"
 131
 132/* Instead of increasing this, you should create a hash table. */
 133#define MAX_GRO_SKBS 8
 134
 135/* This should be increased if a protocol with a bigger head is added. */
 136#define GRO_MAX_HEAD (MAX_HEADER + 128)
 137
 138/*
 139 *      The list of packet types we will receive (as opposed to discard)
 140 *      and the routines to invoke.
 141 *
 142 *      Why 16. Because with 16 the only overlap we get on a hash of the
 143 *      low nibble of the protocol value is RARP/SNAP/X.25.
 144 *
 145 *      NOTE:  That is no longer true with the addition of VLAN tags.  Not
 146 *             sure which should go first, but I bet it won't make much
 147 *             difference if we are running VLANs.  The good news is that
 148 *             this protocol won't be in the list unless compiled in, so
 149 *             the average user (w/out VLANs) will not be adversely affected.
 150 *             --BLG
 151 *
 152 *              0800    IP
 153 *              8100    802.1Q VLAN
 154 *              0001    802.3
 155 *              0002    AX.25
 156 *              0004    802.2
 157 *              8035    RARP
 158 *              0005    SNAP
 159 *              0805    X.25
 160 *              0806    ARP
 161 *              8137    IPX
 162 *              0009    Localtalk
 163 *              86DD    IPv6
 164 */
 165
 166#define PTYPE_HASH_SIZE (16)
 167#define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
 168
 169static DEFINE_SPINLOCK(ptype_lock);
 170static struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
 171static struct list_head ptype_all __read_mostly;        /* Taps */
 172
 173/*
 174 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
 175 * semaphore.
 176 *
 177 * Pure readers hold dev_base_lock for reading.
 178 *
 179 * Writers must hold the rtnl semaphore while they loop through the
 180 * dev_base_head list, and hold dev_base_lock for writing when they do the
 181 * actual updates.  This allows pure readers to access the list even
 182 * while a writer is preparing to update it.
 183 *
 184 * To put it another way, dev_base_lock is held for writing only to
 185 * protect against pure readers; the rtnl semaphore provides the
 186 * protection against other writers.
 187 *
 188 * See, for example usages, register_netdevice() and
 189 * unregister_netdevice(), which must be called with the rtnl
 190 * semaphore held.
 191 */
 192DEFINE_RWLOCK(dev_base_lock);
 193
 194EXPORT_SYMBOL(dev_base_lock);
 195
 196#define NETDEV_HASHBITS 8
 197#define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
 198
 199static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
 200{
 201        unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
 202        return &net->dev_name_head[hash & ((1 << NETDEV_HASHBITS) - 1)];
 203}
 204
 205static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
 206{
 207        return &net->dev_index_head[ifindex & ((1 << NETDEV_HASHBITS) - 1)];
 208}
 209
 210/* Device list insertion */
 211static int list_netdevice(struct net_device *dev)
 212{
 213        struct net *net = dev_net(dev);
 214
 215        ASSERT_RTNL();
 216
 217        write_lock_bh(&dev_base_lock);
 218        list_add_tail(&dev->dev_list, &net->dev_base_head);
 219        hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
 220        hlist_add_head(&dev->index_hlist, dev_index_hash(net, dev->ifindex));
 221        write_unlock_bh(&dev_base_lock);
 222        return 0;
 223}
 224
 225/* Device list removal */
 226static void unlist_netdevice(struct net_device *dev)
 227{
 228        ASSERT_RTNL();
 229
 230        /* Unlink dev from the device chain */
 231        write_lock_bh(&dev_base_lock);
 232        list_del(&dev->dev_list);
 233        hlist_del(&dev->name_hlist);
 234        hlist_del(&dev->index_hlist);
 235        write_unlock_bh(&dev_base_lock);
 236}
 237
 238/*
 239 *      Our notifier list
 240 */
 241
 242static RAW_NOTIFIER_HEAD(netdev_chain);
 243
 244/*
 245 *      Device drivers call our routines to queue packets here. We empty the
 246 *      queue in the local softnet handler.
 247 */
 248
 249DEFINE_PER_CPU(struct softnet_data, softnet_data);
 250
 251#ifdef CONFIG_LOCKDEP
 252/*
 253 * register_netdevice() inits txq->_xmit_lock and sets lockdep class
 254 * according to dev->type
 255 */
 256static const unsigned short netdev_lock_type[] =
 257        {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
 258         ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
 259         ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
 260         ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
 261         ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
 262         ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
 263         ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
 264         ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
 265         ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
 266         ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
 267         ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
 268         ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
 269         ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
 270         ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET,
 271         ARPHRD_PHONET_PIPE, ARPHRD_VOID, ARPHRD_NONE};
 272
 273static const char *netdev_lock_name[] =
 274        {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
 275         "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
 276         "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
 277         "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
 278         "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
 279         "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
 280         "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
 281         "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
 282         "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
 283         "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
 284         "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
 285         "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
 286         "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
 287         "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET",
 288         "_xmit_PHONET_PIPE", "_xmit_VOID", "_xmit_NONE"};
 289
 290static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
 291static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
 292
 293static inline unsigned short netdev_lock_pos(unsigned short dev_type)
 294{
 295        int i;
 296
 297        for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
 298                if (netdev_lock_type[i] == dev_type)
 299                        return i;
 300        /* the last key is used by default */
 301        return ARRAY_SIZE(netdev_lock_type) - 1;
 302}
 303
 304static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
 305                                                 unsigned short dev_type)
 306{
 307        int i;
 308
 309        i = netdev_lock_pos(dev_type);
 310        lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
 311                                   netdev_lock_name[i]);
 312}
 313
 314static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
 315{
 316        int i;
 317
 318        i = netdev_lock_pos(dev->type);
 319        lockdep_set_class_and_name(&dev->addr_list_lock,
 320                                   &netdev_addr_lock_key[i],
 321                                   netdev_lock_name[i]);
 322}
 323#else
 324static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
 325                                                 unsigned short dev_type)
 326{
 327}
 328static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
 329{
 330}
 331#endif
 332
 333/*******************************************************************************
 334
 335                Protocol management and registration routines
 336
 337*******************************************************************************/
 338
 339/*
 340 *      Add a protocol ID to the list. Now that the input handler is
 341 *      smarter we can dispense with all the messy stuff that used to be
 342 *      here.
 343 *
 344 *      BEWARE!!! Protocol handlers, mangling input packets,
 345 *      MUST BE last in hash buckets and checking protocol handlers
 346 *      MUST start from promiscuous ptype_all chain in net_bh.
 347 *      It is true now, do not change it.
 348 *      Explanation follows: if protocol handler, mangling packet, will
 349 *      be the first on list, it is not able to sense, that packet
 350 *      is cloned and should be copied-on-write, so that it will
 351 *      change it and subsequent readers will get broken packet.
 352 *                                                      --ANK (980803)
 353 */
 354
 355/**
 356 *      dev_add_pack - add packet handler
 357 *      @pt: packet type declaration
 358 *
 359 *      Add a protocol handler to the networking stack. The passed &packet_type
 360 *      is linked into kernel lists and may not be freed until it has been
 361 *      removed from the kernel lists.
 362 *
 363 *      This call does not sleep therefore it can not
 364 *      guarantee all CPU's that are in middle of receiving packets
 365 *      will see the new packet type (until the next received packet).
 366 */
 367
 368void dev_add_pack(struct packet_type *pt)
 369{
 370        int hash;
 371
 372        spin_lock_bh(&ptype_lock);
 373        if (pt->type == htons(ETH_P_ALL))
 374                list_add_rcu(&pt->list, &ptype_all);
 375        else {
 376                hash = ntohs(pt->type) & PTYPE_HASH_MASK;
 377                list_add_rcu(&pt->list, &ptype_base[hash]);
 378        }
 379        spin_unlock_bh(&ptype_lock);
 380}
 381
 382/**
 383 *      __dev_remove_pack        - remove packet handler
 384 *      @pt: packet type declaration
 385 *
 386 *      Remove a protocol handler that was previously added to the kernel
 387 *      protocol handlers by dev_add_pack(). The passed &packet_type is removed
 388 *      from the kernel lists and can be freed or reused once this function
 389 *      returns.
 390 *
 391 *      The packet type might still be in use by receivers
 392 *      and must not be freed until after all the CPU's have gone
 393 *      through a quiescent state.
 394 */
 395void __dev_remove_pack(struct packet_type *pt)
 396{
 397        struct list_head *head;
 398        struct packet_type *pt1;
 399
 400        spin_lock_bh(&ptype_lock);
 401
 402        if (pt->type == htons(ETH_P_ALL))
 403                head = &ptype_all;
 404        else
 405                head = &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
 406
 407        list_for_each_entry(pt1, head, list) {
 408                if (pt == pt1) {
 409                        list_del_rcu(&pt->list);
 410                        goto out;
 411                }
 412        }
 413
 414        printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
 415out:
 416        spin_unlock_bh(&ptype_lock);
 417}
 418/**
 419 *      dev_remove_pack  - remove packet handler
 420 *      @pt: packet type declaration
 421 *
 422 *      Remove a protocol handler that was previously added to the kernel
 423 *      protocol handlers by dev_add_pack(). The passed &packet_type is removed
 424 *      from the kernel lists and can be freed or reused once this function
 425 *      returns.
 426 *
 427 *      This call sleeps to guarantee that no CPU is looking at the packet
 428 *      type after return.
 429 */
 430void dev_remove_pack(struct packet_type *pt)
 431{
 432        __dev_remove_pack(pt);
 433
 434        synchronize_net();
 435}
 436
 437/******************************************************************************
 438
 439                      Device Boot-time Settings Routines
 440
 441*******************************************************************************/
 442
 443/* Boot time configuration table */
 444static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
 445
 446/**
 447 *      netdev_boot_setup_add   - add new setup entry
 448 *      @name: name of the device
 449 *      @map: configured settings for the device
 450 *
 451 *      Adds new setup entry to the dev_boot_setup list.  The function
 452 *      returns 0 on error and 1 on success.  This is a generic routine to
 453 *      all netdevices.
 454 */
 455static int netdev_boot_setup_add(char *name, struct ifmap *map)
 456{
 457        struct netdev_boot_setup *s;
 458        int i;
 459
 460        s = dev_boot_setup;
 461        for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
 462                if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
 463                        memset(s[i].name, 0, sizeof(s[i].name));
 464                        strlcpy(s[i].name, name, IFNAMSIZ);
 465                        memcpy(&s[i].map, map, sizeof(s[i].map));
 466                        break;
 467                }
 468        }
 469
 470        return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
 471}
 472
 473/**
 474 *      netdev_boot_setup_check - check boot time settings
 475 *      @dev: the netdevice
 476 *
 477 *      Check boot time settings for the device.
 478 *      The found settings are set for the device to be used
 479 *      later in the device probing.
 480 *      Returns 0 if no settings found, 1 if they are.
 481 */
 482int netdev_boot_setup_check(struct net_device *dev)
 483{
 484        struct netdev_boot_setup *s = dev_boot_setup;
 485        int i;
 486
 487        for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
 488                if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
 489                    !strcmp(dev->name, s[i].name)) {
 490                        dev->irq        = s[i].map.irq;
 491                        dev->base_addr  = s[i].map.base_addr;
 492                        dev->mem_start  = s[i].map.mem_start;
 493                        dev->mem_end    = s[i].map.mem_end;
 494                        return 1;
 495                }
 496        }
 497        return 0;
 498}
 499
 500
 501/**
 502 *      netdev_boot_base        - get address from boot time settings
 503 *      @prefix: prefix for network device
 504 *      @unit: id for network device
 505 *
 506 *      Check boot time settings for the base address of device.
 507 *      The found settings are set for the device to be used
 508 *      later in the device probing.
 509 *      Returns 0 if no settings found.
 510 */
 511unsigned long netdev_boot_base(const char *prefix, int unit)
 512{
 513        const struct netdev_boot_setup *s = dev_boot_setup;
 514        char name[IFNAMSIZ];
 515        int i;
 516
 517        sprintf(name, "%s%d", prefix, unit);
 518
 519        /*
 520         * If device already registered then return base of 1
 521         * to indicate not to probe for this interface
 522         */
 523        if (__dev_get_by_name(&init_net, name))
 524                return 1;
 525
 526        for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
 527                if (!strcmp(name, s[i].name))
 528                        return s[i].map.base_addr;
 529        return 0;
 530}
 531
 532/*
 533 * Saves at boot time configured settings for any netdevice.
 534 */
 535int __init netdev_boot_setup(char *str)
 536{
 537        int ints[5];
 538        struct ifmap map;
 539
 540        str = get_options(str, ARRAY_SIZE(ints), ints);
 541        if (!str || !*str)
 542                return 0;
 543
 544        /* Save settings */
 545        memset(&map, 0, sizeof(map));
 546        if (ints[0] > 0)
 547                map.irq = ints[1];
 548        if (ints[0] > 1)
 549                map.base_addr = ints[2];
 550        if (ints[0] > 2)
 551                map.mem_start = ints[3];
 552        if (ints[0] > 3)
 553                map.mem_end = ints[4];
 554
 555        /* Add new entry to the list */
 556        return netdev_boot_setup_add(str, &map);
 557}
 558
 559__setup("netdev=", netdev_boot_setup);
 560
 561/*******************************************************************************
 562
 563                            Device Interface Subroutines
 564
 565*******************************************************************************/
 566
 567/**
 568 *      __dev_get_by_name       - find a device by its name
 569 *      @net: the applicable net namespace
 570 *      @name: name to find
 571 *
 572 *      Find an interface by name. Must be called under RTNL semaphore
 573 *      or @dev_base_lock. If the name is found a pointer to the device
 574 *      is returned. If the name is not found then %NULL is returned. The
 575 *      reference counters are not incremented so the caller must be
 576 *      careful with locks.
 577 */
 578
 579struct net_device *__dev_get_by_name(struct net *net, const char *name)
 580{
 581        struct hlist_node *p;
 582
 583        hlist_for_each(p, dev_name_hash(net, name)) {
 584                struct net_device *dev
 585                        = hlist_entry(p, struct net_device, name_hlist);
 586                if (!strncmp(dev->name, name, IFNAMSIZ))
 587                        return dev;
 588        }
 589        return NULL;
 590}
 591
 592/**
 593 *      dev_get_by_name         - find a device by its name
 594 *      @net: the applicable net namespace
 595 *      @name: name to find
 596 *
 597 *      Find an interface by name. This can be called from any
 598 *      context and does its own locking. The returned handle has
 599 *      the usage count incremented and the caller must use dev_put() to
 600 *      release it when it is no longer needed. %NULL is returned if no
 601 *      matching device is found.
 602 */
 603
 604struct net_device *dev_get_by_name(struct net *net, const char *name)
 605{
 606        struct net_device *dev;
 607
 608        read_lock(&dev_base_lock);
 609        dev = __dev_get_by_name(net, name);
 610        if (dev)
 611                dev_hold(dev);
 612        read_unlock(&dev_base_lock);
 613        return dev;
 614}
 615
 616/**
 617 *      __dev_get_by_index - find a device by its ifindex
 618 *      @net: the applicable net namespace
 619 *      @ifindex: index of device
 620 *
 621 *      Search for an interface by index. Returns %NULL if the device
 622 *      is not found or a pointer to the device. The device has not
 623 *      had its reference counter increased so the caller must be careful
 624 *      about locking. The caller must hold either the RTNL semaphore
 625 *      or @dev_base_lock.
 626 */
 627
 628struct net_device *__dev_get_by_index(struct net *net, int ifindex)
 629{
 630        struct hlist_node *p;
 631
 632        hlist_for_each(p, dev_index_hash(net, ifindex)) {
 633                struct net_device *dev
 634                        = hlist_entry(p, struct net_device, index_hlist);
 635                if (dev->ifindex == ifindex)
 636                        return dev;
 637        }
 638        return NULL;
 639}
 640
 641
 642/**
 643 *      dev_get_by_index - find a device by its ifindex
 644 *      @net: the applicable net namespace
 645 *      @ifindex: index of device
 646 *
 647 *      Search for an interface by index. Returns NULL if the device
 648 *      is not found or a pointer to the device. The device returned has
 649 *      had a reference added and the pointer is safe until the user calls
 650 *      dev_put to indicate they have finished with it.
 651 */
 652
 653struct net_device *dev_get_by_index(struct net *net, int ifindex)
 654{
 655        struct net_device *dev;
 656
 657        read_lock(&dev_base_lock);
 658        dev = __dev_get_by_index(net, ifindex);
 659        if (dev)
 660                dev_hold(dev);
 661        read_unlock(&dev_base_lock);
 662        return dev;
 663}
 664
 665/**
 666 *      dev_getbyhwaddr - find a device by its hardware address
 667 *      @net: the applicable net namespace
 668 *      @type: media type of device
 669 *      @ha: hardware address
 670 *
 671 *      Search for an interface by MAC address. Returns NULL if the device
 672 *      is not found or a pointer to the device. The caller must hold the
 673 *      rtnl semaphore. The returned device has not had its ref count increased
 674 *      and the caller must therefore be careful about locking
 675 *
 676 *      BUGS:
 677 *      If the API was consistent this would be __dev_get_by_hwaddr
 678 */
 679
 680struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
 681{
 682        struct net_device *dev;
 683
 684        ASSERT_RTNL();
 685
 686        for_each_netdev(net, dev)
 687                if (dev->type == type &&
 688                    !memcmp(dev->dev_addr, ha, dev->addr_len))
 689                        return dev;
 690
 691        return NULL;
 692}
 693
 694EXPORT_SYMBOL(dev_getbyhwaddr);
 695
 696struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
 697{
 698        struct net_device *dev;
 699
 700        ASSERT_RTNL();
 701        for_each_netdev(net, dev)
 702                if (dev->type == type)
 703                        return dev;
 704
 705        return NULL;
 706}
 707
 708EXPORT_SYMBOL(__dev_getfirstbyhwtype);
 709
 710struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
 711{
 712        struct net_device *dev;
 713
 714        rtnl_lock();
 715        dev = __dev_getfirstbyhwtype(net, type);
 716        if (dev)
 717                dev_hold(dev);
 718        rtnl_unlock();
 719        return dev;
 720}
 721
 722EXPORT_SYMBOL(dev_getfirstbyhwtype);
 723
 724/**
 725 *      dev_get_by_flags - find any device with given flags
 726 *      @net: the applicable net namespace
 727 *      @if_flags: IFF_* values
 728 *      @mask: bitmask of bits in if_flags to check
 729 *
 730 *      Search for any interface with the given flags. Returns NULL if a device
 731 *      is not found or a pointer to the device. The device returned has
 732 *      had a reference added and the pointer is safe until the user calls
 733 *      dev_put to indicate they have finished with it.
 734 */
 735
 736struct net_device * dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)
 737{
 738        struct net_device *dev, *ret;
 739
 740        ret = NULL;
 741        read_lock(&dev_base_lock);
 742        for_each_netdev(net, dev) {
 743                if (((dev->flags ^ if_flags) & mask) == 0) {
 744                        dev_hold(dev);
 745                        ret = dev;
 746                        break;
 747                }
 748        }
 749        read_unlock(&dev_base_lock);
 750        return ret;
 751}
 752
 753/**
 754 *      dev_valid_name - check if name is okay for network device
 755 *      @name: name string
 756 *
 757 *      Network device names need to be valid file names to
 758 *      to allow sysfs to work.  We also disallow any kind of
 759 *      whitespace.
 760 */
 761int dev_valid_name(const char *name)
 762{
 763        if (*name == '\0')
 764                return 0;
 765        if (strlen(name) >= IFNAMSIZ)
 766                return 0;
 767        if (!strcmp(name, ".") || !strcmp(name, ".."))
 768                return 0;
 769
 770        while (*name) {
 771                if (*name == '/' || isspace(*name))
 772                        return 0;
 773                name++;
 774        }
 775        return 1;
 776}
 777
 778/**
 779 *      __dev_alloc_name - allocate a name for a device
 780 *      @net: network namespace to allocate the device name in
 781 *      @name: name format string
 782 *      @buf:  scratch buffer and result name string
 783 *
 784 *      Passed a format string - eg "lt%d" it will try and find a suitable
 785 *      id. It scans list of devices to build up a free map, then chooses
 786 *      the first empty slot. The caller must hold the dev_base or rtnl lock
 787 *      while allocating the name and adding the device in order to avoid
 788 *      duplicates.
 789 *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
 790 *      Returns the number of the unit assigned or a negative errno code.
 791 */
 792
 793static int __dev_alloc_name(struct net *net, const char *name, char *buf)
 794{
 795        int i = 0;
 796        const char *p;
 797        const int max_netdevices = 8*PAGE_SIZE;
 798        unsigned long *inuse;
 799        struct net_device *d;
 800
 801        p = strnchr(name, IFNAMSIZ-1, '%');
 802        if (p) {
 803                /*
 804                 * Verify the string as this thing may have come from
 805                 * the user.  There must be either one "%d" and no other "%"
 806                 * characters.
 807                 */
 808                if (p[1] != 'd' || strchr(p + 2, '%'))
 809                        return -EINVAL;
 810
 811                /* Use one page as a bit array of possible slots */
 812                inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
 813                if (!inuse)
 814                        return -ENOMEM;
 815
 816                for_each_netdev(net, d) {
 817                        if (!sscanf(d->name, name, &i))
 818                                continue;
 819                        if (i < 0 || i >= max_netdevices)
 820                                continue;
 821
 822                        /*  avoid cases where sscanf is not exact inverse of printf */
 823                        snprintf(buf, IFNAMSIZ, name, i);
 824                        if (!strncmp(buf, d->name, IFNAMSIZ))
 825                                set_bit(i, inuse);
 826                }
 827
 828                i = find_first_zero_bit(inuse, max_netdevices);
 829                free_page((unsigned long) inuse);
 830        }
 831
 832        snprintf(buf, IFNAMSIZ, name, i);
 833        if (!__dev_get_by_name(net, buf))
 834                return i;
 835
 836        /* It is possible to run out of possible slots
 837         * when the name is long and there isn't enough space left
 838         * for the digits, or if all bits are used.
 839         */
 840        return -ENFILE;
 841}
 842
 843/**
 844 *      dev_alloc_name - allocate a name for a device
 845 *      @dev: device
 846 *      @name: name format string
 847 *
 848 *      Passed a format string - eg "lt%d" it will try and find a suitable
 849 *      id. It scans list of devices to build up a free map, then chooses
 850 *      the first empty slot. The caller must hold the dev_base or rtnl lock
 851 *      while allocating the name and adding the device in order to avoid
 852 *      duplicates.
 853 *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
 854 *      Returns the number of the unit assigned or a negative errno code.
 855 */
 856
 857int dev_alloc_name(struct net_device *dev, const char *name)
 858{
 859        char buf[IFNAMSIZ];
 860        struct net *net;
 861        int ret;
 862
 863        BUG_ON(!dev_net(dev));
 864        net = dev_net(dev);
 865        ret = __dev_alloc_name(net, name, buf);
 866        if (ret >= 0)
 867                strlcpy(dev->name, buf, IFNAMSIZ);
 868        return ret;
 869}
 870
 871
 872/**
 873 *      dev_change_name - change name of a device
 874 *      @dev: device
 875 *      @newname: name (or format string) must be at least IFNAMSIZ
 876 *
 877 *      Change name of a device, can pass format strings "eth%d".
 878 *      for wildcarding.
 879 */
 880int dev_change_name(struct net_device *dev, const char *newname)
 881{
 882        char oldname[IFNAMSIZ];
 883        int err = 0;
 884        int ret;
 885        struct net *net;
 886
 887        ASSERT_RTNL();
 888        BUG_ON(!dev_net(dev));
 889
 890        net = dev_net(dev);
 891        if (dev->flags & IFF_UP)
 892                return -EBUSY;
 893
 894        if (!dev_valid_name(newname))
 895                return -EINVAL;
 896
 897        if (strncmp(newname, dev->name, IFNAMSIZ) == 0)
 898                return 0;
 899
 900        memcpy(oldname, dev->name, IFNAMSIZ);
 901
 902        if (strchr(newname, '%')) {
 903                err = dev_alloc_name(dev, newname);
 904                if (err < 0)
 905                        return err;
 906        }
 907        else if (__dev_get_by_name(net, newname))
 908                return -EEXIST;
 909        else
 910                strlcpy(dev->name, newname, IFNAMSIZ);
 911
 912rollback:
 913        /* For now only devices in the initial network namespace
 914         * are in sysfs.
 915         */
 916        if (net == &init_net) {
 917                ret = device_rename(&dev->dev, dev->name);
 918                if (ret) {
 919                        memcpy(dev->name, oldname, IFNAMSIZ);
 920                        return ret;
 921                }
 922        }
 923
 924        write_lock_bh(&dev_base_lock);
 925        hlist_del(&dev->name_hlist);
 926        hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
 927        write_unlock_bh(&dev_base_lock);
 928
 929        ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
 930        ret = notifier_to_errno(ret);
 931
 932        if (ret) {
 933                if (err) {
 934                        printk(KERN_ERR
 935                               "%s: name change rollback failed: %d.\n",
 936                               dev->name, ret);
 937                } else {
 938                        err = ret;
 939                        memcpy(dev->name, oldname, IFNAMSIZ);
 940                        goto rollback;
 941                }
 942        }
 943
 944        return err;
 945}
 946
 947/**
 948 *      dev_set_alias - change ifalias of a device
 949 *      @dev: device
 950 *      @alias: name up to IFALIASZ
 951 *      @len: limit of bytes to copy from info
 952 *
 953 *      Set ifalias for a device,
 954 */
 955int dev_set_alias(struct net_device *dev, const char *alias, size_t len)
 956{
 957        ASSERT_RTNL();
 958
 959        if (len >= IFALIASZ)
 960                return -EINVAL;
 961
 962        if (!len) {
 963                if (dev->ifalias) {
 964                        kfree(dev->ifalias);
 965                        dev->ifalias = NULL;
 966                }
 967                return 0;
 968        }
 969
 970        dev->ifalias = krealloc(dev->ifalias, len+1, GFP_KERNEL);
 971        if (!dev->ifalias)
 972                return -ENOMEM;
 973
 974        strlcpy(dev->ifalias, alias, len+1);
 975        return len;
 976}
 977
 978
 979/**
 980 *      netdev_features_change - device changes features
 981 *      @dev: device to cause notification
 982 *
 983 *      Called to indicate a device has changed features.
 984 */
 985void netdev_features_change(struct net_device *dev)
 986{
 987        call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
 988}
 989EXPORT_SYMBOL(netdev_features_change);
 990
 991/**
 992 *      netdev_state_change - device changes state
 993 *      @dev: device to cause notification
 994 *
 995 *      Called to indicate a device has changed state. This function calls
 996 *      the notifier chains for netdev_chain and sends a NEWLINK message
 997 *      to the routing socket.
 998 */
 999void netdev_state_change(struct net_device *dev)
1000{
1001        if (dev->flags & IFF_UP) {
1002                call_netdevice_notifiers(NETDEV_CHANGE, dev);
1003                rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
1004        }
1005}
1006
1007void netdev_bonding_change(struct net_device *dev)
1008{
1009        call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, dev);
1010}
1011EXPORT_SYMBOL(netdev_bonding_change);
1012
1013/**
1014 *      dev_load        - load a network module
1015 *      @net: the applicable net namespace
1016 *      @name: name of interface
1017 *
1018 *      If a network interface is not present and the process has suitable
1019 *      privileges this function loads the module. If module loading is not
1020 *      available in this kernel then it becomes a nop.
1021 */
1022
1023void dev_load(struct net *net, const char *name)
1024{
1025        struct net_device *dev;
1026
1027        read_lock(&dev_base_lock);
1028        dev = __dev_get_by_name(net, name);
1029        read_unlock(&dev_base_lock);
1030
1031        if (!dev && capable(CAP_SYS_MODULE))
1032                request_module("%s", name);
1033}
1034
1035/**
1036 *      dev_open        - prepare an interface for use.
1037 *      @dev:   device to open
1038 *
1039 *      Takes a device from down to up state. The device's private open
1040 *      function is invoked and then the multicast lists are loaded. Finally
1041 *      the device is moved into the up state and a %NETDEV_UP message is
1042 *      sent to the netdev notifier chain.
1043 *
1044 *      Calling this function on an active interface is a nop. On a failure
1045 *      a negative errno code is returned.
1046 */
1047int dev_open(struct net_device *dev)
1048{
1049        const struct net_device_ops *ops = dev->netdev_ops;
1050        int ret = 0;
1051
1052        ASSERT_RTNL();
1053
1054        /*
1055         *      Is it already up?
1056         */
1057
1058        if (dev->flags & IFF_UP)
1059                return 0;
1060
1061        /*
1062         *      Is it even present?
1063         */
1064        if (!netif_device_present(dev))
1065                return -ENODEV;
1066
1067        /*
1068         *      Call device private open method
1069         */
1070        set_bit(__LINK_STATE_START, &dev->state);
1071
1072        if (ops->ndo_validate_addr)
1073                ret = ops->ndo_validate_addr(dev);
1074
1075        if (!ret && ops->ndo_open)
1076                ret = ops->ndo_open(dev);
1077
1078        /*
1079         *      If it went open OK then:
1080         */
1081
1082        if (ret)
1083                clear_bit(__LINK_STATE_START, &dev->state);
1084        else {
1085                /*
1086                 *      Set the flags.
1087                 */
1088                dev->flags |= IFF_UP;
1089
1090                /*
1091                 *      Enable NET_DMA
1092                 */
1093                net_dmaengine_get();
1094
1095                /*
1096                 *      Initialize multicasting status
1097                 */
1098                dev_set_rx_mode(dev);
1099
1100                /*
1101                 *      Wakeup transmit queue engine
1102                 */
1103                dev_activate(dev);
1104
1105                /*
1106                 *      ... and announce new interface.
1107                 */
1108                call_netdevice_notifiers(NETDEV_UP, dev);
1109        }
1110
1111        return ret;
1112}
1113
1114/**
1115 *      dev_close - shutdown an interface.
1116 *      @dev: device to shutdown
1117 *
1118 *      This function moves an active device into down state. A
1119 *      %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1120 *      is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1121 *      chain.
1122 */
1123int dev_close(struct net_device *dev)
1124{
1125        const struct net_device_ops *ops = dev->netdev_ops;
1126        ASSERT_RTNL();
1127
1128        might_sleep();
1129
1130        if (!(dev->flags & IFF_UP))
1131                return 0;
1132
1133        /*
1134         *      Tell people we are going down, so that they can
1135         *      prepare to death, when device is still operating.
1136         */
1137        call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1138
1139        clear_bit(__LINK_STATE_START, &dev->state);
1140
1141        /* Synchronize to scheduled poll. We cannot touch poll list,
1142         * it can be even on different cpu. So just clear netif_running().
1143         *
1144         * dev->stop() will invoke napi_disable() on all of it's
1145         * napi_struct instances on this device.
1146         */
1147        smp_mb__after_clear_bit(); /* Commit netif_running(). */
1148
1149        dev_deactivate(dev);
1150
1151        /*
1152         *      Call the device specific close. This cannot fail.
1153         *      Only if device is UP
1154         *
1155         *      We allow it to be called even after a DETACH hot-plug
1156         *      event.
1157         */
1158        if (ops->ndo_stop)
1159                ops->ndo_stop(dev);
1160
1161        /*
1162         *      Device is now down.
1163         */
1164
1165        dev->flags &= ~IFF_UP;
1166
1167        /*
1168         * Tell people we are down
1169         */
1170        call_netdevice_notifiers(NETDEV_DOWN, dev);
1171
1172        /*
1173         *      Shutdown NET_DMA
1174         */
1175        net_dmaengine_put();
1176
1177        return 0;
1178}
1179
1180
1181/**
1182 *      dev_disable_lro - disable Large Receive Offload on a device
1183 *      @dev: device
1184 *
1185 *      Disable Large Receive Offload (LRO) on a net device.  Must be
1186 *      called under RTNL.  This is needed if received packets may be
1187 *      forwarded to another interface.
1188 */
1189void dev_disable_lro(struct net_device *dev)
1190{
1191        if (dev->ethtool_ops && dev->ethtool_ops->get_flags &&
1192            dev->ethtool_ops->set_flags) {
1193                u32 flags = dev->ethtool_ops->get_flags(dev);
1194                if (flags & ETH_FLAG_LRO) {
1195                        flags &= ~ETH_FLAG_LRO;
1196                        dev->ethtool_ops->set_flags(dev, flags);
1197                }
1198        }
1199        WARN_ON(dev->features & NETIF_F_LRO);
1200}
1201EXPORT_SYMBOL(dev_disable_lro);
1202
1203
1204static int dev_boot_phase = 1;
1205
1206/*
1207 *      Device change register/unregister. These are not inline or static
1208 *      as we export them to the world.
1209 */
1210
1211/**
1212 *      register_netdevice_notifier - register a network notifier block
1213 *      @nb: notifier
1214 *
1215 *      Register a notifier to be called when network device events occur.
1216 *      The notifier passed is linked into the kernel structures and must
1217 *      not be reused until it has been unregistered. A negative errno code
1218 *      is returned on a failure.
1219 *
1220 *      When registered all registration and up events are replayed
1221 *      to the new notifier to allow device to have a race free
1222 *      view of the network device list.
1223 */
1224
1225int register_netdevice_notifier(struct notifier_block *nb)
1226{
1227        struct net_device *dev;
1228        struct net_device *last;
1229        struct net *net;
1230        int err;
1231
1232        rtnl_lock();
1233        err = raw_notifier_chain_register(&netdev_chain, nb);
1234        if (err)
1235                goto unlock;
1236        if (dev_boot_phase)
1237                goto unlock;
1238        for_each_net(net) {
1239                for_each_netdev(net, dev) {
1240                        err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1241                        err = notifier_to_errno(err);
1242                        if (err)
1243                                goto rollback;
1244
1245                        if (!(dev->flags & IFF_UP))
1246                                continue;
1247
1248                        nb->notifier_call(nb, NETDEV_UP, dev);
1249                }
1250        }
1251
1252unlock:
1253        rtnl_unlock();
1254        return err;
1255
1256rollback:
1257        last = dev;
1258        for_each_net(net) {
1259                for_each_netdev(net, dev) {
1260                        if (dev == last)
1261                                break;
1262
1263                        if (dev->flags & IFF_UP) {
1264                                nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1265                                nb->notifier_call(nb, NETDEV_DOWN, dev);
1266                        }
1267                        nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1268                }
1269        }
1270
1271        raw_notifier_chain_unregister(&netdev_chain, nb);
1272        goto unlock;
1273}
1274
1275/**
1276 *      unregister_netdevice_notifier - unregister a network notifier block
1277 *      @nb: notifier
1278 *
1279 *      Unregister a notifier previously registered by
1280 *      register_netdevice_notifier(). The notifier is unlinked into the
1281 *      kernel structures and may then be reused. A negative errno code
1282 *      is returned on a failure.
1283 */
1284
1285int unregister_netdevice_notifier(struct notifier_block *nb)
1286{
1287        int err;
1288
1289        rtnl_lock();
1290        err = raw_notifier_chain_unregister(&netdev_chain, nb);
1291        rtnl_unlock();
1292        return err;
1293}
1294
1295/**
1296 *      call_netdevice_notifiers - call all network notifier blocks
1297 *      @val: value passed unmodified to notifier function
1298 *      @dev: net_device pointer passed unmodified to notifier function
1299 *
1300 *      Call all network notifier blocks.  Parameters and return value
1301 *      are as for raw_notifier_call_chain().
1302 */
1303
1304int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1305{
1306        return raw_notifier_call_chain(&netdev_chain, val, dev);
1307}
1308
1309/* When > 0 there are consumers of rx skb time stamps */
1310static atomic_t netstamp_needed = ATOMIC_INIT(0);
1311
1312void net_enable_timestamp(void)
1313{
1314        atomic_inc(&netstamp_needed);
1315}
1316
1317void net_disable_timestamp(void)
1318{
1319        atomic_dec(&netstamp_needed);
1320}
1321
1322static inline void net_timestamp(struct sk_buff *skb)
1323{
1324        if (atomic_read(&netstamp_needed))
1325                __net_timestamp(skb);
1326        else
1327                skb->tstamp.tv64 = 0;
1328}
1329
1330/*
1331 *      Support routine. Sends outgoing frames to any network
1332 *      taps currently in use.
1333 */
1334
1335static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1336{
1337        struct packet_type *ptype;
1338
1339#ifdef CONFIG_NET_CLS_ACT
1340        if (!(skb->tstamp.tv64 && (G_TC_FROM(skb->tc_verd) & AT_INGRESS)))
1341                net_timestamp(skb);
1342#else
1343        net_timestamp(skb);
1344#endif
1345
1346        rcu_read_lock();
1347        list_for_each_entry_rcu(ptype, &ptype_all, list) {
1348                /* Never send packets back to the socket
1349                 * they originated from - MvS (miquels@drinkel.ow.org)
1350                 */
1351                if ((ptype->dev == dev || !ptype->dev) &&
1352                    (ptype->af_packet_priv == NULL ||
1353                     (struct sock *)ptype->af_packet_priv != skb->sk)) {
1354                        struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1355                        if (!skb2)
1356                                break;
1357
1358                        /* skb->nh should be correctly
1359                           set by sender, so that the second statement is
1360                           just protection against buggy protocols.
1361                         */
1362                        skb_reset_mac_header(skb2);
1363
1364                        if (skb_network_header(skb2) < skb2->data ||
1365                            skb2->network_header > skb2->tail) {
1366                                if (net_ratelimit())
1367                                        printk(KERN_CRIT "protocol %04x is "
1368                                               "buggy, dev %s\n",
1369                                               skb2->protocol, dev->name);
1370                                skb_reset_network_header(skb2);
1371                        }
1372
1373                        skb2->transport_header = skb2->network_header;
1374                        skb2->pkt_type = PACKET_OUTGOING;
1375                        ptype->func(skb2, skb->dev, ptype, skb->dev);
1376                }
1377        }
1378        rcu_read_unlock();
1379}
1380
1381
1382static inline void __netif_reschedule(struct Qdisc *q)
1383{
1384        struct softnet_data *sd;
1385        unsigned long flags;
1386
1387        local_irq_save(flags);
1388        sd = &__get_cpu_var(softnet_data);
1389        q->next_sched = sd->output_queue;
1390        sd->output_queue = q;
1391        raise_softirq_irqoff(NET_TX_SOFTIRQ);
1392        local_irq_restore(flags);
1393}
1394
1395void __netif_schedule(struct Qdisc *q)
1396{
1397        if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
1398                __netif_reschedule(q);
1399}
1400EXPORT_SYMBOL(__netif_schedule);
1401
1402void dev_kfree_skb_irq(struct sk_buff *skb)
1403{
1404        if (atomic_dec_and_test(&skb->users)) {
1405                struct softnet_data *sd;
1406                unsigned long flags;
1407
1408                local_irq_save(flags);
1409                sd = &__get_cpu_var(softnet_data);
1410                skb->next = sd->completion_queue;
1411                sd->completion_queue = skb;
1412                raise_softirq_irqoff(NET_TX_SOFTIRQ);
1413                local_irq_restore(flags);
1414        }
1415}
1416EXPORT_SYMBOL(dev_kfree_skb_irq);
1417
1418void dev_kfree_skb_any(struct sk_buff *skb)
1419{
1420        if (in_irq() || irqs_disabled())
1421                dev_kfree_skb_irq(skb);
1422        else
1423                dev_kfree_skb(skb);
1424}
1425EXPORT_SYMBOL(dev_kfree_skb_any);
1426
1427
1428/**
1429 * netif_device_detach - mark device as removed
1430 * @dev: network device
1431 *
1432 * Mark device as removed from system and therefore no longer available.
1433 */
1434void netif_device_detach(struct net_device *dev)
1435{
1436        if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1437            netif_running(dev)) {
1438                netif_tx_stop_all_queues(dev);
1439        }
1440}
1441EXPORT_SYMBOL(netif_device_detach);
1442
1443/**
1444 * netif_device_attach - mark device as attached
1445 * @dev: network device
1446 *
1447 * Mark device as attached from system and restart if needed.
1448 */
1449void netif_device_attach(struct net_device *dev)
1450{
1451        if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1452            netif_running(dev)) {
1453                netif_tx_wake_all_queues(dev);
1454                __netdev_watchdog_up(dev);
1455        }
1456}
1457EXPORT_SYMBOL(netif_device_attach);
1458
1459static bool can_checksum_protocol(unsigned long features, __be16 protocol)
1460{
1461        return ((features & NETIF_F_GEN_CSUM) ||
1462                ((features & NETIF_F_IP_CSUM) &&
1463                 protocol == htons(ETH_P_IP)) ||
1464                ((features & NETIF_F_IPV6_CSUM) &&
1465                 protocol == htons(ETH_P_IPV6)) ||
1466                ((features & NETIF_F_FCOE_CRC) &&
1467                 protocol == htons(ETH_P_FCOE)));
1468}
1469
1470static bool dev_can_checksum(struct net_device *dev, struct sk_buff *skb)
1471{
1472        if (can_checksum_protocol(dev->features, skb->protocol))
1473                return true;
1474
1475        if (skb->protocol == htons(ETH_P_8021Q)) {
1476                struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
1477                if (can_checksum_protocol(dev->features & dev->vlan_features,
1478                                          veh->h_vlan_encapsulated_proto))
1479                        return true;
1480        }
1481
1482        return false;
1483}
1484
1485/*
1486 * Invalidate hardware checksum when packet is to be mangled, and
1487 * complete checksum manually on outgoing path.
1488 */
1489int skb_checksum_help(struct sk_buff *skb)
1490{
1491        __wsum csum;
1492        int ret = 0, offset;
1493
1494        if (skb->ip_summed == CHECKSUM_COMPLETE)
1495                goto out_set_summed;
1496
1497        if (unlikely(skb_shinfo(skb)->gso_size)) {
1498                /* Let GSO fix up the checksum. */
1499                goto out_set_summed;
1500        }
1501
1502        offset = skb->csum_start - skb_headroom(skb);
1503        BUG_ON(offset >= skb_headlen(skb));
1504        csum = skb_checksum(skb, offset, skb->len - offset, 0);
1505
1506        offset += skb->csum_offset;
1507        BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1508
1509        if (skb_cloned(skb) &&
1510            !skb_clone_writable(skb, offset + sizeof(__sum16))) {
1511                ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1512                if (ret)
1513                        goto out;
1514        }
1515
1516        *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1517out_set_summed:
1518        skb->ip_summed = CHECKSUM_NONE;
1519out:
1520        return ret;
1521}
1522
1523/**
1524 *      skb_gso_segment - Perform segmentation on skb.
1525 *      @skb: buffer to segment
1526 *      @features: features for the output path (see dev->features)
1527 *
1528 *      This function segments the given skb and returns a list of segments.
1529 *
1530 *      It may return NULL if the skb requires no segmentation.  This is
1531 *      only possible when GSO is used for verifying header integrity.
1532 */
1533struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
1534{
1535        struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1536        struct packet_type *ptype;
1537        __be16 type = skb->protocol;
1538        int err;
1539
1540        skb_reset_mac_header(skb);
1541        skb->mac_len = skb->network_header - skb->mac_header;
1542        __skb_pull(skb, skb->mac_len);
1543
1544        if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1545                struct net_device *dev = skb->dev;
1546                struct ethtool_drvinfo info = {};
1547
1548                if (dev && dev->ethtool_ops && dev->ethtool_ops->get_drvinfo)
1549                        dev->ethtool_ops->get_drvinfo(dev, &info);
1550
1551                WARN(1, "%s: caps=(0x%lx, 0x%lx) len=%d data_len=%d "
1552                        "ip_summed=%d",
1553                     info.driver, dev ? dev->features : 0L,
1554                     skb->sk ? skb->sk->sk_route_caps : 0L,
1555                     skb->len, skb->data_len, skb->ip_summed);
1556
1557                if (skb_header_cloned(skb) &&
1558                    (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1559                        return ERR_PTR(err);
1560        }
1561
1562        rcu_read_lock();
1563        list_for_each_entry_rcu(ptype,
1564                        &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
1565                if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1566                        if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1567                                err = ptype->gso_send_check(skb);
1568                                segs = ERR_PTR(err);
1569                                if (err || skb_gso_ok(skb, features))
1570                                        break;
1571                                __skb_push(skb, (skb->data -
1572                                                 skb_network_header(skb)));
1573                        }
1574                        segs = ptype->gso_segment(skb, features);
1575                        break;
1576                }
1577        }
1578        rcu_read_unlock();
1579
1580        __skb_push(skb, skb->data - skb_mac_header(skb));
1581
1582        return segs;
1583}
1584
1585EXPORT_SYMBOL(skb_gso_segment);
1586
1587/* Take action when hardware reception checksum errors are detected. */
1588#ifdef CONFIG_BUG
1589void netdev_rx_csum_fault(struct net_device *dev)
1590{
1591        if (net_ratelimit()) {
1592                printk(KERN_ERR "%s: hw csum failure.\n",
1593                        dev ? dev->name : "<unknown>");
1594                dump_stack();
1595        }
1596}
1597EXPORT_SYMBOL(netdev_rx_csum_fault);
1598#endif
1599
1600/* Actually, we should eliminate this check as soon as we know, that:
1601 * 1. IOMMU is present and allows to map all the memory.
1602 * 2. No high memory really exists on this machine.
1603 */
1604
1605static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1606{
1607#ifdef CONFIG_HIGHMEM
1608        int i;
1609
1610        if (dev->features & NETIF_F_HIGHDMA)
1611                return 0;
1612
1613        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1614                if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1615                        return 1;
1616
1617#endif
1618        return 0;
1619}
1620
1621struct dev_gso_cb {
1622        void (*destructor)(struct sk_buff *skb);
1623};
1624
1625#define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1626
1627static void dev_gso_skb_destructor(struct sk_buff *skb)
1628{
1629        struct dev_gso_cb *cb;
1630
1631        do {
1632                struct sk_buff *nskb = skb->next;
1633
1634                skb->next = nskb->next;
1635                nskb->next = NULL;
1636                kfree_skb(nskb);
1637        } while (skb->next);
1638
1639        cb = DEV_GSO_CB(skb);
1640        if (cb->destructor)
1641                cb->destructor(skb);
1642}
1643
1644/**
1645 *      dev_gso_segment - Perform emulated hardware segmentation on skb.
1646 *      @skb: buffer to segment
1647 *
1648 *      This function segments the given skb and stores the list of segments
1649 *      in skb->next.
1650 */
1651static int dev_gso_segment(struct sk_buff *skb)
1652{
1653        struct net_device *dev = skb->dev;
1654        struct sk_buff *segs;
1655        int features = dev->features & ~(illegal_highdma(dev, skb) ?
1656                                         NETIF_F_SG : 0);
1657
1658        segs = skb_gso_segment(skb, features);
1659
1660        /* Verifying header integrity only. */
1661        if (!segs)
1662                return 0;
1663
1664        if (IS_ERR(segs))
1665                return PTR_ERR(segs);
1666
1667        skb->next = segs;
1668        DEV_GSO_CB(skb)->destructor = skb->destructor;
1669        skb->destructor = dev_gso_skb_destructor;
1670
1671        return 0;
1672}
1673
1674int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
1675                        struct netdev_queue *txq)
1676{
1677        const struct net_device_ops *ops = dev->netdev_ops;
1678        int rc;
1679
1680        if (likely(!skb->next)) {
1681                if (!list_empty(&ptype_all))
1682                        dev_queue_xmit_nit(skb, dev);
1683
1684                if (netif_needs_gso(dev, skb)) {
1685                        if (unlikely(dev_gso_segment(skb)))
1686                                goto out_kfree_skb;
1687                        if (skb->next)
1688                                goto gso;
1689                }
1690
1691                rc = ops->ndo_start_xmit(skb, dev);
1692                /*
1693                 * TODO: if skb_orphan() was called by
1694                 * dev->hard_start_xmit() (for example, the unmodified
1695                 * igb driver does that; bnx2 doesn't), then
1696                 * skb_tx_software_timestamp() will be unable to send
1697                 * back the time stamp.
1698                 *
1699                 * How can this be prevented? Always create another
1700                 * reference to the socket before calling
1701                 * dev->hard_start_xmit()? Prevent that skb_orphan()
1702                 * does anything in dev->hard_start_xmit() by clearing
1703                 * the skb destructor before the call and restoring it
1704                 * afterwards, then doing the skb_orphan() ourselves?
1705                 */
1706                return rc;
1707        }
1708
1709gso:
1710        do {
1711                struct sk_buff *nskb = skb->next;
1712
1713                skb->next = nskb->next;
1714                nskb->next = NULL;
1715                rc = ops->ndo_start_xmit(nskb, dev);
1716                if (unlikely(rc)) {
1717                        nskb->next = skb->next;
1718                        skb->next = nskb;
1719                        return rc;
1720                }
1721                if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
1722                        return NETDEV_TX_BUSY;
1723        } while (skb->next);
1724
1725        skb->destructor = DEV_GSO_CB(skb)->destructor;
1726
1727out_kfree_skb:
1728        kfree_skb(skb);
1729        return 0;
1730}
1731
1732static u32 skb_tx_hashrnd;
1733
1734u16 skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb)
1735{
1736        u32 hash;
1737
1738        if (skb_rx_queue_recorded(skb))
1739                return skb_get_rx_queue(skb) % dev->real_num_tx_queues;
1740
1741        if (skb->sk && skb->sk->sk_hash)
1742                hash = skb->sk->sk_hash;
1743        else
1744                hash = skb->protocol;
1745
1746        hash = jhash_1word(hash, skb_tx_hashrnd);
1747
1748        return (u16) (((u64) hash * dev->real_num_tx_queues) >> 32);
1749}
1750EXPORT_SYMBOL(skb_tx_hash);
1751
1752static struct netdev_queue *dev_pick_tx(struct net_device *dev,
1753                                        struct sk_buff *skb)
1754{
1755        const struct net_device_ops *ops = dev->netdev_ops;
1756        u16 queue_index = 0;
1757
1758        if (ops->ndo_select_queue)
1759                queue_index = ops->ndo_select_queue(dev, skb);
1760        else if (dev->real_num_tx_queues > 1)
1761                queue_index = skb_tx_hash(dev, skb);
1762
1763        skb_set_queue_mapping(skb, queue_index);
1764        return netdev_get_tx_queue(dev, queue_index);
1765}
1766
1767/**
1768 *      dev_queue_xmit - transmit a buffer
1769 *      @skb: buffer to transmit
1770 *
1771 *      Queue a buffer for transmission to a network device. The caller must
1772 *      have set the device and priority and built the buffer before calling
1773 *      this function. The function can be called from an interrupt.
1774 *
1775 *      A negative errno code is returned on a failure. A success does not
1776 *      guarantee the frame will be transmitted as it may be dropped due
1777 *      to congestion or traffic shaping.
1778 *
1779 * -----------------------------------------------------------------------------------
1780 *      I notice this method can also return errors from the queue disciplines,
1781 *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
1782 *      be positive.
1783 *
1784 *      Regardless of the return value, the skb is consumed, so it is currently
1785 *      difficult to retry a send to this method.  (You can bump the ref count
1786 *      before sending to hold a reference for retry if you are careful.)
1787 *
1788 *      When calling this method, interrupts MUST be enabled.  This is because
1789 *      the BH enable code must have IRQs enabled so that it will not deadlock.
1790 *          --BLG
1791 */
1792int dev_queue_xmit(struct sk_buff *skb)
1793{
1794        struct net_device *dev = skb->dev;
1795        struct netdev_queue *txq;
1796        struct Qdisc *q;
1797        int rc = -ENOMEM;
1798
1799        /* GSO will handle the following emulations directly. */
1800        if (netif_needs_gso(dev, skb))
1801                goto gso;
1802
1803        if (skb_shinfo(skb)->frag_list &&
1804            !(dev->features & NETIF_F_FRAGLIST) &&
1805            __skb_linearize(skb))
1806                goto out_kfree_skb;
1807
1808        /* Fragmented skb is linearized if device does not support SG,
1809         * or if at least one of fragments is in highmem and device
1810         * does not support DMA from it.
1811         */
1812        if (skb_shinfo(skb)->nr_frags &&
1813            (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1814            __skb_linearize(skb))
1815                goto out_kfree_skb;
1816
1817        /* If packet is not checksummed and device does not support
1818         * checksumming for this protocol, complete checksumming here.
1819         */
1820        if (skb->ip_summed == CHECKSUM_PARTIAL) {
1821                skb_set_transport_header(skb, skb->csum_start -
1822                                              skb_headroom(skb));
1823                if (!dev_can_checksum(dev, skb) && skb_checksum_help(skb))
1824                        goto out_kfree_skb;
1825        }
1826
1827gso:
1828        /* Disable soft irqs for various locks below. Also
1829         * stops preemption for RCU.
1830         */
1831        rcu_read_lock_bh();
1832
1833        txq = dev_pick_tx(dev, skb);
1834        q = rcu_dereference(txq->qdisc);
1835
1836#ifdef CONFIG_NET_CLS_ACT
1837        skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1838#endif
1839        if (q->enqueue) {
1840                spinlock_t *root_lock = qdisc_lock(q);
1841
1842                spin_lock(root_lock);
1843
1844                if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
1845                        kfree_skb(skb);
1846                        rc = NET_XMIT_DROP;
1847                } else {
1848                        rc = qdisc_enqueue_root(skb, q);
1849                        qdisc_run(q);
1850                }
1851                spin_unlock(root_lock);
1852
1853                goto out;
1854        }
1855
1856        /* The device has no queue. Common case for software devices:
1857           loopback, all the sorts of tunnels...
1858
1859           Really, it is unlikely that netif_tx_lock protection is necessary
1860           here.  (f.e. loopback and IP tunnels are clean ignoring statistics
1861           counters.)
1862           However, it is possible, that they rely on protection
1863           made by us here.
1864
1865           Check this and shot the lock. It is not prone from deadlocks.
1866           Either shot noqueue qdisc, it is even simpler 8)
1867         */
1868        if (dev->flags & IFF_UP) {
1869                int cpu = smp_processor_id(); /* ok because BHs are off */
1870
1871                if (txq->xmit_lock_owner != cpu) {
1872
1873                        HARD_TX_LOCK(dev, txq, cpu);
1874
1875                        if (!netif_tx_queue_stopped(txq)) {
1876                                rc = 0;
1877                                if (!dev_hard_start_xmit(skb, dev, txq)) {
1878                                        HARD_TX_UNLOCK(dev, txq);
1879                                        goto out;
1880                                }
1881                        }
1882                        HARD_TX_UNLOCK(dev, txq);
1883                        if (net_ratelimit())
1884                                printk(KERN_CRIT "Virtual device %s asks to "
1885                                       "queue packet!\n", dev->name);
1886                } else {
1887                        /* Recursion is detected! It is possible,
1888                         * unfortunately */
1889                        if (net_ratelimit())
1890                                printk(KERN_CRIT "Dead loop on virtual device "
1891                                       "%s, fix it urgently!\n", dev->name);
1892                }
1893        }
1894
1895        rc = -ENETDOWN;
1896        rcu_read_unlock_bh();
1897
1898out_kfree_skb:
1899        kfree_skb(skb);
1900        return rc;
1901out:
1902        rcu_read_unlock_bh();
1903        return rc;
1904}
1905
1906
1907/*=======================================================================
1908                        Receiver routines
1909  =======================================================================*/
1910
1911int netdev_max_backlog __read_mostly = 1000;
1912int netdev_budget __read_mostly = 300;
1913int weight_p __read_mostly = 64;            /* old backlog weight */
1914
1915DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1916
1917
1918/**
1919 *      netif_rx        -       post buffer to the network code
1920 *      @skb: buffer to post
1921 *
1922 *      This function receives a packet from a device driver and queues it for
1923 *      the upper (protocol) levels to process.  It always succeeds. The buffer
1924 *      may be dropped during processing for congestion control or by the
1925 *      protocol layers.
1926 *
1927 *      return values:
1928 *      NET_RX_SUCCESS  (no congestion)
1929 *      NET_RX_DROP     (packet was dropped)
1930 *
1931 */
1932
1933int netif_rx(struct sk_buff *skb)
1934{
1935        struct softnet_data *queue;
1936        unsigned long flags;
1937
1938        /* if netpoll wants it, pretend we never saw it */
1939        if (netpoll_rx(skb))
1940                return NET_RX_DROP;
1941
1942        if (!skb->tstamp.tv64)
1943                net_timestamp(skb);
1944
1945        /*
1946         * The code is rearranged so that the path is the most
1947         * short when CPU is congested, but is still operating.
1948         */
1949        local_irq_save(flags);
1950        queue = &__get_cpu_var(softnet_data);
1951
1952        __get_cpu_var(netdev_rx_stat).total++;
1953        if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1954                if (queue->input_pkt_queue.qlen) {
1955enqueue:
1956                        __skb_queue_tail(&queue->input_pkt_queue, skb);
1957                        local_irq_restore(flags);
1958                        return NET_RX_SUCCESS;
1959                }
1960
1961                napi_schedule(&queue->backlog);
1962                goto enqueue;
1963        }
1964
1965        __get_cpu_var(netdev_rx_stat).dropped++;
1966        local_irq_restore(flags);
1967
1968        kfree_skb(skb);
1969        return NET_RX_DROP;
1970}
1971
1972int netif_rx_ni(struct sk_buff *skb)
1973{
1974        int err;
1975
1976        preempt_disable();
1977        err = netif_rx(skb);
1978        if (local_softirq_pending())
1979                do_softirq();
1980        preempt_enable();
1981
1982        return err;
1983}
1984
1985EXPORT_SYMBOL(netif_rx_ni);
1986
1987static void net_tx_action(struct softirq_action *h)
1988{
1989        struct softnet_data *sd = &__get_cpu_var(softnet_data);
1990
1991        if (sd->completion_queue) {
1992                struct sk_buff *clist;
1993
1994                local_irq_disable();
1995                clist = sd->completion_queue;
1996                sd->completion_queue = NULL;
1997                local_irq_enable();
1998
1999                while (clist) {
2000                        struct sk_buff *skb = clist;
2001                        clist = clist->next;
2002
2003                        WARN_ON(atomic_read(&skb->users));
2004                        __kfree_skb(skb);
2005                }
2006        }
2007
2008        if (sd->output_queue) {
2009                struct Qdisc *head;
2010
2011                local_irq_disable();
2012                head = sd->output_queue;
2013                sd->output_queue = NULL;
2014                local_irq_enable();
2015
2016                while (head) {
2017                        struct Qdisc *q = head;
2018                        spinlock_t *root_lock;
2019
2020                        head = head->next_sched;
2021
2022                        root_lock = qdisc_lock(q);
2023                        if (spin_trylock(root_lock)) {
2024                                smp_mb__before_clear_bit();
2025                                clear_bit(__QDISC_STATE_SCHED,
2026                                          &q->state);
2027                                qdisc_run(q);
2028                                spin_unlock(root_lock);
2029                        } else {
2030                                if (!test_bit(__QDISC_STATE_DEACTIVATED,
2031                                              &q->state)) {
2032                                        __netif_reschedule(q);
2033                                } else {
2034                                        smp_mb__before_clear_bit();
2035                                        clear_bit(__QDISC_STATE_SCHED,
2036                                                  &q->state);
2037                                }
2038                        }
2039                }
2040        }
2041}
2042
2043static inline int deliver_skb(struct sk_buff *skb,
2044                              struct packet_type *pt_prev,
2045                              struct net_device *orig_dev)
2046{
2047        atomic_inc(&skb->users);
2048        return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2049}
2050
2051#if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
2052/* These hooks defined here for ATM */
2053struct net_bridge;
2054struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
2055                                                unsigned char *addr);
2056void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
2057
2058/*
2059 * If bridge module is loaded call bridging hook.
2060 *  returns NULL if packet was consumed.
2061 */
2062struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
2063                                        struct sk_buff *skb) __read_mostly;
2064static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
2065                                            struct packet_type **pt_prev, int *ret,
2066                                            struct net_device *orig_dev)
2067{
2068        struct net_bridge_port *port;
2069
2070        if (skb->pkt_type == PACKET_LOOPBACK ||
2071            (port = rcu_dereference(skb->dev->br_port)) == NULL)
2072                return skb;
2073
2074        if (*pt_prev) {
2075                *ret = deliver_skb(skb, *pt_prev, orig_dev);
2076                *pt_prev = NULL;
2077        }
2078
2079        return br_handle_frame_hook(port, skb);
2080}
2081#else
2082#define handle_bridge(skb, pt_prev, ret, orig_dev)      (skb)
2083#endif
2084
2085#if defined(CONFIG_MACVLAN) || defined(CONFIG_MACVLAN_MODULE)
2086struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *skb) __read_mostly;
2087EXPORT_SYMBOL_GPL(macvlan_handle_frame_hook);
2088
2089static inline struct sk_buff *handle_macvlan(struct sk_buff *skb,
2090                                             struct packet_type **pt_prev,
2091                                             int *ret,
2092                                             struct net_device *orig_dev)
2093{
2094        if (skb->dev->macvlan_port == NULL)
2095                return skb;
2096
2097        if (*pt_prev) {
2098                *ret = deliver_skb(skb, *pt_prev, orig_dev);
2099                *pt_prev = NULL;
2100        }
2101        return macvlan_handle_frame_hook(skb);
2102}
2103#else
2104#define handle_macvlan(skb, pt_prev, ret, orig_dev)     (skb)
2105#endif
2106
2107#ifdef CONFIG_NET_CLS_ACT
2108/* TODO: Maybe we should just force sch_ingress to be compiled in
2109 * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
2110 * a compare and 2 stores extra right now if we dont have it on
2111 * but have CONFIG_NET_CLS_ACT
2112 * NOTE: This doesnt stop any functionality; if you dont have
2113 * the ingress scheduler, you just cant add policies on ingress.
2114 *
2115 */
2116static int ing_filter(struct sk_buff *skb)
2117{
2118        struct net_device *dev = skb->dev;
2119        u32 ttl = G_TC_RTTL(skb->tc_verd);
2120        struct netdev_queue *rxq;
2121        int result = TC_ACT_OK;
2122        struct Qdisc *q;
2123
2124        if (MAX_RED_LOOP < ttl++) {
2125                printk(KERN_WARNING
2126                       "Redir loop detected Dropping packet (%d->%d)\n",
2127                       skb->iif, dev->ifindex);
2128                return TC_ACT_SHOT;
2129        }
2130
2131        skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
2132        skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
2133
2134        rxq = &dev->rx_queue;
2135
2136        q = rxq->qdisc;
2137        if (q != &noop_qdisc) {
2138                spin_lock(qdisc_lock(q));
2139                if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
2140                        result = qdisc_enqueue_root(skb, q);
2141                spin_unlock(qdisc_lock(q));
2142        }
2143
2144        return result;
2145}
2146
2147static inline struct sk_buff *handle_ing(struct sk_buff *skb,
2148                                         struct packet_type **pt_prev,
2149                                         int *ret, struct net_device *orig_dev)
2150{
2151        if (skb->dev->rx_queue.qdisc == &noop_qdisc)
2152                goto out;
2153
2154        if (*pt_prev) {
2155                *ret = deliver_skb(skb, *pt_prev, orig_dev);
2156                *pt_prev = NULL;
2157        } else {
2158                /* Huh? Why does turning on AF_PACKET affect this? */
2159                skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
2160        }
2161
2162        switch (ing_filter(skb)) {
2163        case TC_ACT_SHOT:
2164        case TC_ACT_STOLEN:
2165                kfree_skb(skb);
2166                return NULL;
2167        }
2168
2169out:
2170        skb->tc_verd = 0;
2171        return skb;
2172}
2173#endif
2174
2175/*
2176 *      netif_nit_deliver - deliver received packets to network taps
2177 *      @skb: buffer
2178 *
2179 *      This function is used to deliver incoming packets to network
2180 *      taps. It should be used when the normal netif_receive_skb path
2181 *      is bypassed, for example because of VLAN acceleration.
2182 */
2183void netif_nit_deliver(struct sk_buff *skb)
2184{
2185        struct packet_type *ptype;
2186
2187        if (list_empty(&ptype_all))
2188                return;
2189
2190        skb_reset_network_header(skb);
2191        skb_reset_transport_header(skb);
2192        skb->mac_len = skb->network_header - skb->mac_header;
2193
2194        rcu_read_lock();
2195        list_for_each_entry_rcu(ptype, &ptype_all, list) {
2196                if (!ptype->dev || ptype->dev == skb->dev)
2197                        deliver_skb(skb, ptype, skb->dev);
2198        }
2199        rcu_read_unlock();
2200}
2201
2202/**
2203 *      netif_receive_skb - process receive buffer from network
2204 *      @skb: buffer to process
2205 *
2206 *      netif_receive_skb() is the main receive data processing function.
2207 *      It always succeeds. The buffer may be dropped during processing
2208 *      for congestion control or by the protocol layers.
2209 *
2210 *      This function may only be called from softirq context and interrupts
2211 *      should be enabled.
2212 *
2213 *      Return values (usually ignored):
2214 *      NET_RX_SUCCESS: no congestion
2215 *      NET_RX_DROP: packet was dropped
2216 */
2217int netif_receive_skb(struct sk_buff *skb)
2218{
2219        struct packet_type *ptype, *pt_prev;
2220        struct net_device *orig_dev;
2221        struct net_device *null_or_orig;
2222        int ret = NET_RX_DROP;
2223        __be16 type;
2224
2225        if (skb->vlan_tci && vlan_hwaccel_do_receive(skb))
2226                return NET_RX_SUCCESS;
2227
2228        /* if we've gotten here through NAPI, check netpoll */
2229        if (netpoll_receive_skb(skb))
2230                return NET_RX_DROP;
2231
2232        if (!skb->tstamp.tv64)
2233                net_timestamp(skb);
2234
2235        if (!skb->iif)
2236                skb->iif = skb->dev->ifindex;
2237
2238        null_or_orig = NULL;
2239        orig_dev = skb->dev;
2240        if (orig_dev->master) {
2241                if (skb_bond_should_drop(skb))
2242                        null_or_orig = orig_dev; /* deliver only exact match */
2243                else
2244                        skb->dev = orig_dev->master;
2245        }
2246
2247        __get_cpu_var(netdev_rx_stat).total++;
2248
2249        skb_reset_network_header(skb);
2250        skb_reset_transport_header(skb);
2251        skb->mac_len = skb->network_header - skb->mac_header;
2252
2253        pt_prev = NULL;
2254
2255        rcu_read_lock();
2256
2257#ifdef CONFIG_NET_CLS_ACT
2258        if (skb->tc_verd & TC_NCLS) {
2259                skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2260                goto ncls;
2261        }
2262#endif
2263
2264        list_for_each_entry_rcu(ptype, &ptype_all, list) {
2265                if (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
2266                    ptype->dev == orig_dev) {
2267                        if (pt_prev)
2268                                ret = deliver_skb(skb, pt_prev, orig_dev);
2269                        pt_prev = ptype;
2270                }
2271        }
2272
2273#ifdef CONFIG_NET_CLS_ACT
2274        skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2275        if (!skb)
2276                goto out;
2277ncls:
2278#endif
2279
2280        skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
2281        if (!skb)
2282                goto out;
2283        skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
2284        if (!skb)
2285                goto out;
2286
2287        skb_orphan(skb);
2288
2289        type = skb->protocol;
2290        list_for_each_entry_rcu(ptype,
2291                        &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
2292                if (ptype->type == type &&
2293                    (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
2294                     ptype->dev == orig_dev)) {
2295                        if (pt_prev)
2296                                ret = deliver_skb(skb, pt_prev, orig_dev);
2297                        pt_prev = ptype;
2298                }
2299        }
2300
2301        if (pt_prev) {
2302                ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2303        } else {
2304                kfree_skb(skb);
2305                /* Jamal, now you will not able to escape explaining
2306                 * me how you were going to use this. :-)
2307                 */
2308                ret = NET_RX_DROP;
2309        }
2310
2311out:
2312        rcu_read_unlock();
2313        return ret;
2314}
2315
2316/* Network device is going away, flush any packets still pending  */
2317static void flush_backlog(void *arg)
2318{
2319        struct net_device *dev = arg;
2320        struct softnet_data *queue = &__get_cpu_var(softnet_data);
2321        struct sk_buff *skb, *tmp;
2322
2323        skb_queue_walk_safe(&queue->input_pkt_queue, skb, tmp)
2324                if (skb->dev == dev) {
2325                        __skb_unlink(skb, &queue->input_pkt_queue);
2326                        kfree_skb(skb);
2327                }
2328}
2329
2330static int napi_gro_complete(struct sk_buff *skb)
2331{
2332        struct packet_type *ptype;
2333        __be16 type = skb->protocol;
2334        struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
2335        int err = -ENOENT;
2336
2337        if (NAPI_GRO_CB(skb)->count == 1) {
2338                skb_shinfo(skb)->gso_size = 0;
2339                goto out;
2340        }
2341
2342        rcu_read_lock();
2343        list_for_each_entry_rcu(ptype, head, list) {
2344                if (ptype->type != type || ptype->dev || !ptype->gro_complete)
2345                        continue;
2346
2347                err = ptype->gro_complete(skb);
2348                break;
2349        }
2350        rcu_read_unlock();
2351
2352        if (err) {
2353                WARN_ON(&ptype->list == head);
2354                kfree_skb(skb);
2355                return NET_RX_SUCCESS;
2356        }
2357
2358out:
2359        return netif_receive_skb(skb);
2360}
2361
2362void napi_gro_flush(struct napi_struct *napi)
2363{
2364        struct sk_buff *skb, *next;
2365
2366        for (skb = napi->gro_list; skb; skb = next) {
2367                next = skb->next;
2368                skb->next = NULL;
2369                napi_gro_complete(skb);
2370        }
2371
2372        napi->gro_count = 0;
2373        napi->gro_list = NULL;
2374}
2375EXPORT_SYMBOL(napi_gro_flush);
2376
2377void *skb_gro_header(struct sk_buff *skb, unsigned int hlen)
2378{
2379        unsigned int offset = skb_gro_offset(skb);
2380
2381        hlen += offset;
2382        if (hlen <= skb_headlen(skb))
2383                return skb->data + offset;
2384
2385        if (unlikely(!skb_shinfo(skb)->nr_frags ||
2386                     skb_shinfo(skb)->frags[0].size <=
2387                     hlen - skb_headlen(skb) ||
2388                     PageHighMem(skb_shinfo(skb)->frags[0].page)))
2389                return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
2390
2391        return page_address(skb_shinfo(skb)->frags[0].page) +
2392               skb_shinfo(skb)->frags[0].page_offset +
2393               offset - skb_headlen(skb);
2394}
2395EXPORT_SYMBOL(skb_gro_header);
2396
2397int dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
2398{
2399        struct sk_buff **pp = NULL;
2400        struct packet_type *ptype;
2401        __be16 type = skb->protocol;
2402        struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
2403        int same_flow;
2404        int mac_len;
2405        int ret;
2406
2407        if (!(skb->dev->features & NETIF_F_GRO))
2408                goto normal;
2409
2410        if (skb_is_gso(skb) || skb_shinfo(skb)->frag_list)
2411                goto normal;
2412
2413        rcu_read_lock();
2414        list_for_each_entry_rcu(ptype, head, list) {
2415                if (ptype->type != type || ptype->dev || !ptype->gro_receive)
2416                        continue;
2417
2418                skb_set_network_header(skb, skb_gro_offset(skb));
2419                mac_len = skb->network_header - skb->mac_header;
2420                skb->mac_len = mac_len;
2421                NAPI_GRO_CB(skb)->same_flow = 0;
2422                NAPI_GRO_CB(skb)->flush = 0;
2423                NAPI_GRO_CB(skb)->free = 0;
2424
2425                pp = ptype->gro_receive(&napi->gro_list, skb);
2426                break;
2427        }
2428        rcu_read_unlock();
2429
2430        if (&ptype->list == head)
2431                goto normal;
2432
2433        same_flow = NAPI_GRO_CB(skb)->same_flow;
2434        ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED;
2435
2436        if (pp) {
2437                struct sk_buff *nskb = *pp;
2438
2439                *pp = nskb->next;
2440                nskb->next = NULL;
2441                napi_gro_complete(nskb);
2442                napi->gro_count--;
2443        }
2444
2445        if (same_flow)
2446                goto ok;
2447
2448        if (NAPI_GRO_CB(skb)->flush || napi->gro_count >= MAX_GRO_SKBS)
2449                goto normal;
2450
2451        napi->gro_count++;
2452        NAPI_GRO_CB(skb)->count = 1;
2453        skb_shinfo(skb)->gso_size = skb_gro_len(skb);
2454        skb->next = napi->gro_list;
2455        napi->gro_list = skb;
2456        ret = GRO_HELD;
2457
2458pull:
2459        if (unlikely(!pskb_may_pull(skb, skb_gro_offset(skb)))) {
2460                if (napi->gro_list == skb)
2461                        napi->gro_list = skb->next;
2462                ret = GRO_DROP;
2463        }
2464
2465ok:
2466        return ret;
2467
2468normal:
2469        ret = GRO_NORMAL;
2470        goto pull;
2471}
2472EXPORT_SYMBOL(dev_gro_receive);
2473
2474static int __napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
2475{
2476        struct sk_buff *p;
2477
2478        if (netpoll_rx_on(skb))
2479                return GRO_NORMAL;
2480
2481        for (p = napi->gro_list; p; p = p->next) {
2482                NAPI_GRO_CB(p)->same_flow = (p->dev == skb->dev)
2483                        && !compare_ether_header(skb_mac_header(p),
2484                                                 skb_gro_mac_header(skb));
2485                NAPI_GRO_CB(p)->flush = 0;
2486        }
2487
2488        return dev_gro_receive(napi, skb);
2489}
2490
2491int napi_skb_finish(int ret, struct sk_buff *skb)
2492{
2493        int err = NET_RX_SUCCESS;
2494
2495        switch (ret) {
2496        case GRO_NORMAL:
2497                return netif_receive_skb(skb);
2498
2499        case GRO_DROP:
2500                err = NET_RX_DROP;
2501                /* fall through */
2502
2503        case GRO_MERGED_FREE:
2504                kfree_skb(skb);
2505                break;
2506        }
2507
2508        return err;
2509}
2510EXPORT_SYMBOL(napi_skb_finish);
2511
2512int napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
2513{
2514        skb_gro_reset_offset(skb);
2515
2516        return napi_skb_finish(__napi_gro_receive(napi, skb), skb);
2517}
2518EXPORT_SYMBOL(napi_gro_receive);
2519
2520void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
2521{
2522        __skb_pull(skb, skb_headlen(skb));
2523        skb_reserve(skb, NET_IP_ALIGN - skb_headroom(skb));
2524
2525        napi->skb = skb;
2526}
2527EXPORT_SYMBOL(napi_reuse_skb);
2528
2529struct sk_buff *napi_fraginfo_skb(struct napi_struct *napi,
2530                                  struct napi_gro_fraginfo *info)
2531{
2532        struct net_device *dev = napi->dev;
2533        struct sk_buff *skb = napi->skb;
2534        struct ethhdr *eth;
2535        skb_frag_t *frag;
2536        int i;
2537
2538        napi->skb = NULL;
2539
2540        if (!skb) {
2541                skb = netdev_alloc_skb(dev, GRO_MAX_HEAD + NET_IP_ALIGN);
2542                if (!skb)
2543                        goto out;
2544
2545                skb_reserve(skb, NET_IP_ALIGN);
2546        }
2547
2548        BUG_ON(info->nr_frags > MAX_SKB_FRAGS);
2549        frag = info->frags;
2550
2551        for (i = 0; i < info->nr_frags; i++) {
2552                skb_fill_page_desc(skb, i, frag->page, frag->page_offset,
2553                                   frag->size);
2554                frag++;
2555        }
2556        skb_shinfo(skb)->nr_frags = info->nr_frags;
2557
2558        skb->data_len = info->len;
2559        skb->len += info->len;
2560        skb->truesize += info->len;
2561
2562        skb_reset_mac_header(skb);
2563        skb_gro_reset_offset(skb);
2564
2565        eth = skb_gro_header(skb, sizeof(*eth));
2566        if (!eth) {
2567                napi_reuse_skb(napi, skb);
2568                skb = NULL;
2569                goto out;
2570        }
2571
2572        skb_gro_pull(skb, sizeof(*eth));
2573
2574        /*
2575         * This works because the only protocols we care about don't require
2576         * special handling.  We'll fix it up properly at the end.
2577         */
2578        skb->protocol = eth->h_proto;
2579
2580        skb->ip_summed = info->ip_summed;
2581        skb->csum = info->csum;
2582
2583out:
2584        return skb;
2585}
2586EXPORT_SYMBOL(napi_fraginfo_skb);
2587
2588int napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb, int ret)
2589{
2590        int err = NET_RX_SUCCESS;
2591
2592        switch (ret) {
2593        case GRO_NORMAL:
2594        case GRO_HELD:
2595                skb->protocol = eth_type_trans(skb, napi->dev);
2596
2597                if (ret == GRO_NORMAL)
2598                        return netif_receive_skb(skb);
2599
2600                skb_gro_pull(skb, -ETH_HLEN);
2601                break;
2602
2603        case GRO_DROP:
2604                err = NET_RX_DROP;
2605                /* fall through */
2606
2607        case GRO_MERGED_FREE:
2608                napi_reuse_skb(napi, skb);
2609                break;
2610        }
2611
2612        return err;
2613}
2614EXPORT_SYMBOL(napi_frags_finish);
2615
2616int napi_gro_frags(struct napi_struct *napi, struct napi_gro_fraginfo *info)
2617{
2618        struct sk_buff *skb = napi_fraginfo_skb(napi, info);
2619
2620        if (!skb)
2621                return NET_RX_DROP;
2622
2623        return napi_frags_finish(napi, skb, __napi_gro_receive(napi, skb));
2624}
2625EXPORT_SYMBOL(napi_gro_frags);
2626
2627static int process_backlog(struct napi_struct *napi, int quota)
2628{
2629        int work = 0;
2630        struct softnet_data *queue = &__get_cpu_var(softnet_data);
2631        unsigned long start_time = jiffies;
2632
2633        napi->weight = weight_p;
2634        do {
2635                struct sk_buff *skb;
2636
2637                local_irq_disable();
2638                skb = __skb_dequeue(&queue->input_pkt_queue);
2639                if (!skb) {
2640                        __napi_complete(napi);
2641                        local_irq_enable();
2642                        break;
2643                }
2644                local_irq_enable();
2645
2646                netif_receive_skb(skb);
2647        } while (++work < quota && jiffies == start_time);
2648
2649        return work;
2650}
2651
2652/**
2653 * __napi_schedule - schedule for receive
2654 * @n: entry to schedule
2655 *
2656 * The entry's receive function will be scheduled to run
2657 */
2658void __napi_schedule(struct napi_struct *n)
2659{
2660        unsigned long flags;
2661
2662        local_irq_save(flags);
2663        list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
2664        __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2665        local_irq_restore(flags);
2666}
2667EXPORT_SYMBOL(__napi_schedule);
2668
2669void __napi_complete(struct napi_struct *n)
2670{
2671        BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
2672        BUG_ON(n->gro_list);
2673
2674        list_del(&n->poll_list);
2675        smp_mb__before_clear_bit();
2676        clear_bit(NAPI_STATE_SCHED, &n->state);
2677}
2678EXPORT_SYMBOL(__napi_complete);
2679
2680void napi_complete(struct napi_struct *n)
2681{
2682        unsigned long flags;
2683
2684        /*
2685         * don't let napi dequeue from the cpu poll list
2686         * just in case its running on a different cpu
2687         */
2688        if (unlikely(test_bit(NAPI_STATE_NPSVC, &n->state)))
2689                return;
2690
2691        napi_gro_flush(n);
2692        local_irq_save(flags);
2693        __napi_complete(n);
2694        local_irq_restore(flags);
2695}
2696EXPORT_SYMBOL(napi_complete);
2697
2698void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
2699                    int (*poll)(struct napi_struct *, int), int weight)
2700{
2701        INIT_LIST_HEAD(&napi->poll_list);
2702        napi->gro_count = 0;
2703        napi->gro_list = NULL;
2704        napi->skb = NULL;
2705        napi->poll = poll;
2706        napi->weight = weight;
2707        list_add(&napi->dev_list, &dev->napi_list);
2708        napi->dev = dev;
2709#ifdef CONFIG_NETPOLL
2710        spin_lock_init(&napi->poll_lock);
2711        napi->poll_owner = -1;
2712#endif
2713        set_bit(NAPI_STATE_SCHED, &napi->state);
2714}
2715EXPORT_SYMBOL(netif_napi_add);
2716
2717void netif_napi_del(struct napi_struct *napi)
2718{
2719        struct sk_buff *skb, *next;
2720
2721        list_del_init(&napi->dev_list);
2722        kfree_skb(napi->skb);
2723
2724        for (skb = napi->gro_list; skb; skb = next) {
2725                next = skb->next;
2726                skb->next = NULL;
2727                kfree_skb(skb);
2728        }
2729
2730        napi->gro_list = NULL;
2731        napi->gro_count = 0;
2732}
2733EXPORT_SYMBOL(netif_napi_del);
2734
2735
2736static void net_rx_action(struct softirq_action *h)
2737{
2738        struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
2739        unsigned long time_limit = jiffies + 2;
2740        int budget = netdev_budget;
2741        void *have;
2742
2743        local_irq_disable();
2744
2745        while (!list_empty(list)) {
2746                struct napi_struct *n;
2747                int work, weight;
2748
2749                /* If softirq window is exhuasted then punt.
2750                 * Allow this to run for 2 jiffies since which will allow
2751                 * an average latency of 1.5/HZ.
2752                 */
2753                if (unlikely(budget <= 0 || time_after(jiffies, time_limit)))
2754                        goto softnet_break;
2755
2756                local_irq_enable();
2757
2758                /* Even though interrupts have been re-enabled, this
2759                 * access is safe because interrupts can only add new
2760                 * entries to the tail of this list, and only ->poll()
2761                 * calls can remove this head entry from the list.
2762                 */
2763                n = list_entry(list->next, struct napi_struct, poll_list);
2764
2765                have = netpoll_poll_lock(n);
2766
2767                weight = n->weight;
2768
2769                /* This NAPI_STATE_SCHED test is for avoiding a race
2770                 * with netpoll's poll_napi().  Only the entity which
2771                 * obtains the lock and sees NAPI_STATE_SCHED set will
2772                 * actually make the ->poll() call.  Therefore we avoid
2773                 * accidently calling ->poll() when NAPI is not scheduled.
2774                 */
2775                work = 0;
2776                if (test_bit(NAPI_STATE_SCHED, &n->state))
2777                        work = n->poll(n, weight);
2778
2779                WARN_ON_ONCE(work > weight);
2780
2781                budget -= work;
2782
2783                local_irq_disable();
2784
2785                /* Drivers must not modify the NAPI state if they
2786                 * consume the entire weight.  In such cases this code
2787                 * still "owns" the NAPI instance and therefore can
2788                 * move the instance around on the list at-will.
2789                 */
2790                if (unlikely(work == weight)) {
2791                        if (unlikely(napi_disable_pending(n)))
2792                                __napi_complete(n);
2793                        else
2794                                list_move_tail(&n->poll_list, list);
2795                }
2796
2797                netpoll_poll_unlock(have);
2798        }
2799out:
2800        local_irq_enable();
2801
2802#ifdef CONFIG_NET_DMA
2803        /*
2804         * There may not be any more sk_buffs coming right now, so push
2805         * any pending DMA copies to hardware
2806         */
2807        dma_issue_pending_all();
2808#endif
2809
2810        return;
2811
2812softnet_break:
2813        __get_cpu_var(netdev_rx_stat).time_squeeze++;
2814        __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2815        goto out;
2816}
2817
2818static gifconf_func_t * gifconf_list [NPROTO];
2819
2820/**
2821 *      register_gifconf        -       register a SIOCGIF handler
2822 *      @family: Address family
2823 *      @gifconf: Function handler
2824 *
2825 *      Register protocol dependent address dumping routines. The handler
2826 *      that is passed must not be freed or reused until it has been replaced
2827 *      by another handler.
2828 */
2829int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
2830{
2831        if (family >= NPROTO)
2832                return -EINVAL;
2833        gifconf_list[family] = gifconf;
2834        return 0;
2835}
2836
2837
2838/*
2839 *      Map an interface index to its name (SIOCGIFNAME)
2840 */
2841
2842/*
2843 *      We need this ioctl for efficient implementation of the
2844 *      if_indextoname() function required by the IPv6 API.  Without
2845 *      it, we would have to search all the interfaces to find a
2846 *      match.  --pb
2847 */
2848
2849static int dev_ifname(struct net *net, struct ifreq __user *arg)
2850{
2851        struct net_device *dev;
2852        struct ifreq ifr;
2853
2854        /*
2855         *      Fetch the caller's info block.
2856         */
2857
2858        if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2859                return -EFAULT;
2860
2861        read_lock(&dev_base_lock);
2862        dev = __dev_get_by_index(net, ifr.ifr_ifindex);
2863        if (!dev) {
2864                read_unlock(&dev_base_lock);
2865                return -ENODEV;
2866        }
2867
2868        strcpy(ifr.ifr_name, dev->name);
2869        read_unlock(&dev_base_lock);
2870
2871        if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2872                return -EFAULT;
2873        return 0;
2874}
2875
2876/*
2877 *      Perform a SIOCGIFCONF call. This structure will change
2878 *      size eventually, and there is nothing I can do about it.
2879 *      Thus we will need a 'compatibility mode'.
2880 */
2881
2882static int dev_ifconf(struct net *net, char __user *arg)
2883{
2884        struct ifconf ifc;
2885        struct net_device *dev;
2886        char __user *pos;
2887        int len;
2888        int total;
2889        int i;
2890
2891        /*
2892         *      Fetch the caller's info block.
2893         */
2894
2895        if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2896                return -EFAULT;
2897
2898        pos = ifc.ifc_buf;
2899        len = ifc.ifc_len;
2900
2901        /*
2902         *      Loop over the interfaces, and write an info block for each.
2903         */
2904
2905        total = 0;
2906        for_each_netdev(net, dev) {
2907                for (i = 0; i < NPROTO; i++) {
2908                        if (gifconf_list[i]) {
2909                                int done;
2910                                if (!pos)
2911                                        done = gifconf_list[i](dev, NULL, 0);
2912                                else
2913                                        done = gifconf_list[i](dev, pos + total,
2914                                                               len - total);
2915                                if (done < 0)
2916                                        return -EFAULT;
2917                                total += done;
2918                        }
2919                }
2920        }
2921
2922        /*
2923         *      All done.  Write the updated control block back to the caller.
2924         */
2925        ifc.ifc_len = total;
2926
2927        /*
2928         *      Both BSD and Solaris return 0 here, so we do too.
2929         */
2930        return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2931}
2932
2933#ifdef CONFIG_PROC_FS
2934/*
2935 *      This is invoked by the /proc filesystem handler to display a device
2936 *      in detail.
2937 */
2938void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2939        __acquires(dev_base_lock)
2940{
2941        struct net *net = seq_file_net(seq);
2942        loff_t off;
2943        struct net_device *dev;
2944
2945        read_lock(&dev_base_lock);
2946        if (!*pos)
2947                return SEQ_START_TOKEN;
2948
2949        off = 1;
2950        for_each_netdev(net, dev)
2951                if (off++ == *pos)
2952                        return dev;
2953
2954        return NULL;
2955}
2956
2957void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2958{
2959        struct net *net = seq_file_net(seq);
2960        ++*pos;
2961        return v == SEQ_START_TOKEN ?
2962                first_net_device(net) : next_net_device((struct net_device *)v);
2963}
2964
2965void dev_seq_stop(struct seq_file *seq, void *v)
2966        __releases(dev_base_lock)
2967{
2968        read_unlock(&dev_base_lock);
2969}
2970
2971static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2972{
2973        const struct net_device_stats *stats = dev_get_stats(dev);
2974
2975        seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2976                   "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2977                   dev->name, stats->rx_bytes, stats->rx_packets,
2978                   stats->rx_errors,
2979                   stats->rx_dropped + stats->rx_missed_errors,
2980                   stats->rx_fifo_errors,
2981                   stats->rx_length_errors + stats->rx_over_errors +
2982                    stats->rx_crc_errors + stats->rx_frame_errors,
2983                   stats->rx_compressed, stats->multicast,
2984                   stats->tx_bytes, stats->tx_packets,
2985                   stats->tx_errors, stats->tx_dropped,
2986                   stats->tx_fifo_errors, stats->collisions,
2987                   stats->tx_carrier_errors +
2988                    stats->tx_aborted_errors +
2989                    stats->tx_window_errors +
2990                    stats->tx_heartbeat_errors,
2991                   stats->tx_compressed);
2992}
2993
2994/*
2995 *      Called from the PROCfs module. This now uses the new arbitrary sized
2996 *      /proc/net interface to create /proc/net/dev
2997 */
2998static int dev_seq_show(struct seq_file *seq, void *v)
2999{
3000        if (v == SEQ_START_TOKEN)
3001                seq_puts(seq, "Inter-|   Receive                            "
3002                              "                    |  Transmit\n"
3003                              " face |bytes    packets errs drop fifo frame "
3004                              "compressed multicast|bytes    packets errs "
3005                              "drop fifo colls carrier compressed\n");
3006        else
3007                dev_seq_printf_stats(seq, v);
3008        return 0;
3009}
3010
3011static struct netif_rx_stats *softnet_get_online(loff_t *pos)
3012{
3013        struct netif_rx_stats *rc = NULL;
3014
3015        while (*pos < nr_cpu_ids)
3016                if (cpu_online(*pos)) {
3017                        rc = &per_cpu(netdev_rx_stat, *pos);
3018                        break;
3019                } else
3020                        ++*pos;
3021        return rc;
3022}
3023
3024static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
3025{
3026        return softnet_get_online(pos);
3027}
3028
3029static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3030{
3031        ++*pos;
3032        return softnet_get_online(pos);
3033}
3034
3035static void softnet_seq_stop(struct seq_file *seq, void *v)
3036{
3037}
3038
3039static int softnet_seq_show(struct seq_file *seq, void *v)
3040{
3041        struct netif_rx_stats *s = v;
3042
3043        seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
3044                   s->total, s->dropped, s->time_squeeze, 0,
3045                   0, 0, 0, 0, /* was fastroute */
3046                   s->cpu_collision );
3047        return 0;
3048}
3049
3050static const struct seq_operations dev_seq_ops = {
3051        .start = dev_seq_start,
3052        .next  = dev_seq_next,
3053        .stop  = dev_seq_stop,
3054        .show  = dev_seq_show,
3055};
3056
3057static int dev_seq_open(struct inode *inode, struct file *file)
3058{
3059        return seq_open_net(inode, file, &dev_seq_ops,
3060                            sizeof(struct seq_net_private));
3061}
3062
3063static const struct file_operations dev_seq_fops = {
3064        .owner   = THIS_MODULE,
3065        .open    = dev_seq_open,
3066        .read    = seq_read,
3067        .llseek  = seq_lseek,
3068        .release = seq_release_net,
3069};
3070
3071static const struct seq_operations softnet_seq_ops = {
3072        .start = softnet_seq_start,
3073        .next  = softnet_seq_next,
3074        .stop  = softnet_seq_stop,
3075        .show  = softnet_seq_show,
3076};
3077
3078static int softnet_seq_open(struct inode *inode, struct file *file)
3079{
3080        return seq_open(file, &softnet_seq_ops);
3081}
3082
3083static const struct file_operations softnet_seq_fops = {
3084        .owner   = THIS_MODULE,
3085        .open    = softnet_seq_open,
3086        .read    = seq_read,
3087        .llseek  = seq_lseek,
3088        .release = seq_release,
3089};
3090
3091static void *ptype_get_idx(loff_t pos)
3092{
3093        struct packet_type *pt = NULL;
3094        loff_t i = 0;
3095        int t;
3096
3097        list_for_each_entry_rcu(pt, &ptype_all, list) {
3098                if (i == pos)
3099                        return pt;
3100                ++i;
3101        }
3102
3103        for (t = 0; t < PTYPE_HASH_SIZE; t++) {
3104                list_for_each_entry_rcu(pt, &ptype_base[t], list) {
3105                        if (i == pos)
3106                                return pt;
3107                        ++i;
3108                }
3109        }
3110        return NULL;
3111}
3112
3113static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
3114        __acquires(RCU)
3115{
3116        rcu_read_lock();
3117        return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
3118}
3119
3120static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3121{
3122        struct packet_type *pt;
3123        struct list_head *nxt;
3124        int hash;
3125
3126        ++*pos;
3127        if (v == SEQ_START_TOKEN)
3128                return ptype_get_idx(0);
3129
3130        pt = v;
3131        nxt = pt->list.next;
3132        if (pt->type == htons(ETH_P_ALL)) {
3133                if (nxt != &ptype_all)
3134                        goto found;
3135                hash = 0;
3136                nxt = ptype_base[0].next;
3137        } else
3138                hash = ntohs(pt->type) & PTYPE_HASH_MASK;
3139
3140        while (nxt == &ptype_base[hash]) {
3141                if (++hash >= PTYPE_HASH_SIZE)
3142                        return NULL;
3143                nxt = ptype_base[hash].next;
3144        }
3145found:
3146        return list_entry(nxt, struct packet_type, list);
3147}
3148
3149static void ptype_seq_stop(struct seq_file *seq, void *v)
3150        __releases(RCU)
3151{
3152        rcu_read_unlock();
3153}
3154
3155static int ptype_seq_show(struct seq_file *seq, void *v)
3156{
3157        struct packet_type *pt = v;
3158
3159        if (v == SEQ_START_TOKEN)
3160                seq_puts(seq, "Type Device      Function\n");
3161        else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
3162                if (pt->type == htons(ETH_P_ALL))
3163                        seq_puts(seq, "ALL ");
3164                else
3165                        seq_printf(seq, "%04x", ntohs(pt->type));
3166
3167                seq_printf(seq, " %-8s %pF\n",
3168                           pt->dev ? pt->dev->name : "", pt->func);
3169        }
3170
3171        return 0;
3172}
3173
3174static const struct seq_operations ptype_seq_ops = {
3175        .start = ptype_seq_start,
3176        .next  = ptype_seq_next,
3177        .stop  = ptype_seq_stop,
3178        .show  = ptype_seq_show,
3179};
3180
3181static int ptype_seq_open(struct inode *inode, struct file *file)
3182{
3183        return seq_open_net(inode, file, &ptype_seq_ops,
3184                        sizeof(struct seq_net_private));
3185}
3186
3187static const struct file_operations ptype_seq_fops = {
3188        .owner   = THIS_MODULE,
3189        .open    = ptype_seq_open,
3190        .read    = seq_read,
3191        .llseek  = seq_lseek,
3192        .release = seq_release_net,
3193};
3194
3195
3196static int __net_init dev_proc_net_init(struct net *net)
3197{
3198        int rc = -ENOMEM;
3199
3200        if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
3201                goto out;
3202        if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
3203                goto out_dev;
3204        if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
3205                goto out_softnet;
3206
3207        if (wext_proc_init(net))
3208                goto out_ptype;
3209        rc = 0;
3210out:
3211        return rc;
3212out_ptype:
3213        proc_net_remove(net, "ptype");
3214out_softnet:
3215        proc_net_remove(net, "softnet_stat");
3216out_dev:
3217        proc_net_remove(net, "dev");
3218        goto out;
3219}
3220
3221static void __net_exit dev_proc_net_exit(struct net *net)
3222{
3223        wext_proc_exit(net);
3224
3225        proc_net_remove(net, "ptype");
3226        proc_net_remove(net, "softnet_stat");
3227        proc_net_remove(net, "dev");
3228}
3229
3230static struct pernet_operations __net_initdata dev_proc_ops = {
3231        .init = dev_proc_net_init,
3232        .exit = dev_proc_net_exit,
3233};
3234
3235static int __init dev_proc_init(void)
3236{
3237        return register_pernet_subsys(&dev_proc_ops);
3238}
3239#else
3240#define dev_proc_init() 0
3241#endif  /* CONFIG_PROC_FS */
3242
3243
3244/**
3245 *      netdev_set_master       -       set up master/slave pair
3246 *      @slave: slave device
3247 *      @master: new master device
3248 *
3249 *      Changes the master device of the slave. Pass %NULL to break the
3250 *      bonding. The caller must hold the RTNL semaphore. On a failure
3251 *      a negative errno code is returned. On success the reference counts
3252 *      are adjusted, %RTM_NEWLINK is sent to the routing socket and the
3253 *      function returns zero.
3254 */
3255int netdev_set_master(struct net_device *slave, struct net_device *master)
3256{
3257        struct net_device *old = slave->master;
3258
3259        ASSERT_RTNL();
3260
3261        if (master) {
3262                if (old)
3263                        return -EBUSY;
3264                dev_hold(master);
3265        }
3266
3267        slave->master = master;
3268
3269        synchronize_net();
3270
3271        if (old)
3272                dev_put(old);
3273
3274        if (master)
3275                slave->flags |= IFF_SLAVE;
3276        else
3277                slave->flags &= ~IFF_SLAVE;
3278
3279        rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
3280        return 0;
3281}
3282
3283static void dev_change_rx_flags(struct net_device *dev, int flags)
3284{
3285        const struct net_device_ops *ops = dev->netdev_ops;
3286
3287        if ((dev->flags & IFF_UP) && ops->ndo_change_rx_flags)
3288                ops->ndo_change_rx_flags(dev, flags);
3289}
3290
3291static int __dev_set_promiscuity(struct net_device *dev, int inc)
3292{
3293        unsigned short old_flags = dev->flags;
3294        uid_t uid;
3295        gid_t gid;
3296
3297        ASSERT_RTNL();
3298
3299        dev->flags |= IFF_PROMISC;
3300        dev->promiscuity += inc;
3301        if (dev->promiscuity == 0) {
3302                /*
3303                 * Avoid overflow.
3304                 * If inc causes overflow, untouch promisc and return error.
3305                 */
3306                if (inc < 0)
3307                        dev->flags &= ~IFF_PROMISC;
3308                else {
3309                        dev->promiscuity -= inc;
3310                        printk(KERN_WARNING "%s: promiscuity touches roof, "
3311                                "set promiscuity failed, promiscuity feature "
3312                                "of device might be broken.\n", dev->name);
3313                        return -EOVERFLOW;
3314                }
3315        }
3316        if (dev->flags != old_flags) {
3317                printk(KERN_INFO "device %s %s promiscuous mode\n",
3318                       dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
3319                                                               "left");
3320                if (audit_enabled) {
3321                        current_uid_gid(&uid, &gid);
3322                        audit_log(current->audit_context, GFP_ATOMIC,
3323                                AUDIT_ANOM_PROMISCUOUS,
3324                                "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
3325                                dev->name, (dev->flags & IFF_PROMISC),
3326                                (old_flags & IFF_PROMISC),
3327                                audit_get_loginuid(current),
3328                                uid, gid,
3329                                audit_get_sessionid(current));
3330                }
3331
3332                dev_change_rx_flags(dev, IFF_PROMISC);
3333        }
3334        return 0;
3335}
3336
3337/**
3338 *      dev_set_promiscuity     - update promiscuity count on a device
3339 *      @dev: device
3340 *      @inc: modifier
3341 *
3342 *      Add or remove promiscuity from a device. While the count in the device
3343 *      remains above zero the interface remains promiscuous. Once it hits zero
3344 *      the device reverts back to normal filtering operation. A negative inc
3345 *      value is used to drop promiscuity on the device.
3346 *      Return 0 if successful or a negative errno code on error.
3347 */
3348int dev_set_promiscuity(struct net_device *dev, int inc)
3349{
3350        unsigned short old_flags = dev->flags;
3351        int err;
3352
3353        err = __dev_set_promiscuity(dev, inc);
3354        if (err < 0)
3355                return err;
3356        if (dev->flags != old_flags)
3357                dev_set_rx_mode(dev);
3358        return err;
3359}
3360
3361/**
3362 *      dev_set_allmulti        - update allmulti count on a device
3363 *      @dev: device
3364 *      @inc: modifier
3365 *
3366 *      Add or remove reception of all multicast frames to a device. While the
3367 *      count in the device remains above zero the interface remains listening
3368 *      to all interfaces. Once it hits zero the device reverts back to normal
3369 *      filtering operation. A negative @inc value is used to drop the counter
3370 *      when releasing a resource needing all multicasts.
3371 *      Return 0 if successful or a negative errno code on error.
3372 */
3373
3374int dev_set_allmulti(struct net_device *dev, int inc)
3375{
3376        unsigned short old_flags = dev->flags;
3377
3378        ASSERT_RTNL();
3379
3380        dev->flags |= IFF_ALLMULTI;
3381        dev->allmulti += inc;
3382        if (dev->allmulti == 0) {
3383                /*
3384                 * Avoid overflow.
3385                 * If inc causes overflow, untouch allmulti and return error.
3386                 */
3387                if (inc < 0)
3388                        dev->flags &= ~IFF_ALLMULTI;
3389                else {
3390                        dev->allmulti -= inc;
3391                        printk(KERN_WARNING "%s: allmulti touches roof, "
3392                                "set allmulti failed, allmulti feature of "
3393                                "device might be broken.\n", dev->name);
3394                        return -EOVERFLOW;
3395                }
3396        }
3397        if (dev->flags ^ old_flags) {
3398                dev_change_rx_flags(dev, IFF_ALLMULTI);
3399                dev_set_rx_mode(dev);
3400        }
3401        return 0;
3402}
3403
3404/*
3405 *      Upload unicast and multicast address lists to device and
3406 *      configure RX filtering. When the device doesn't support unicast
3407 *      filtering it is put in promiscuous mode while unicast addresses
3408 *      are present.
3409 */
3410void __dev_set_rx_mode(struct net_device *dev)
3411{
3412        const struct net_device_ops *ops = dev->netdev_ops;
3413
3414        /* dev_open will call this function so the list will stay sane. */
3415        if (!(dev->flags&IFF_UP))
3416                return;
3417
3418        if (!netif_device_present(dev))
3419                return;
3420
3421        if (ops->ndo_set_rx_mode)
3422                ops->ndo_set_rx_mode(dev);
3423        else {
3424                /* Unicast addresses changes may only happen under the rtnl,
3425                 * therefore calling __dev_set_promiscuity here is safe.
3426                 */
3427                if (dev->uc_count > 0 && !dev->uc_promisc) {
3428                        __dev_set_promiscuity(dev, 1);
3429                        dev->uc_promisc = 1;
3430                } else if (dev->uc_count == 0 && dev->uc_promisc) {
3431                        __dev_set_promiscuity(dev, -1);
3432                        dev->uc_promisc = 0;
3433                }
3434
3435                if (ops->ndo_set_multicast_list)
3436                        ops->ndo_set_multicast_list(dev);
3437        }
3438}
3439
3440void dev_set_rx_mode(struct net_device *dev)
3441{
3442        netif_addr_lock_bh(dev);
3443        __dev_set_rx_mode(dev);
3444        netif_addr_unlock_bh(dev);
3445}
3446
3447int __dev_addr_delete(struct dev_addr_list **list, int *count,
3448                      void *addr, int alen, int glbl)
3449{
3450        struct dev_addr_list *da;
3451
3452        for (; (da = *list) != NULL; list = &da->next) {
3453                if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3454                    alen == da->da_addrlen) {
3455                        if (glbl) {
3456                                int old_glbl = da->da_gusers;
3457                                da->da_gusers = 0;
3458                                if (old_glbl == 0)
3459                                        break;
3460                        }
3461                        if (--da->da_users)
3462                                return 0;
3463
3464                        *list = da->next;
3465                        kfree(da);
3466                        (*count)--;
3467                        return 0;
3468                }
3469        }
3470        return -ENOENT;
3471}
3472
3473int __dev_addr_add(struct dev_addr_list **list, int *count,
3474                   void *addr, int alen, int glbl)
3475{
3476        struct dev_addr_list *da;
3477
3478        for (da = *list; da != NULL; da = da->next) {
3479                if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3480                    da->da_addrlen == alen) {
3481                        if (glbl) {
3482                                int old_glbl = da->da_gusers;
3483                                da->da_gusers = 1;
3484                                if (old_glbl)
3485                                        return 0;
3486                        }
3487                        da->da_users++;
3488                        return 0;
3489                }
3490        }
3491
3492        da = kzalloc(sizeof(*da), GFP_ATOMIC);
3493        if (da == NULL)
3494                return -ENOMEM;
3495        memcpy(da->da_addr, addr, alen);
3496        da->da_addrlen = alen;
3497        da->da_users = 1;
3498        da->da_gusers = glbl ? 1 : 0;
3499        da->next = *list;
3500        *list = da;
3501        (*count)++;
3502        return 0;
3503}
3504
3505/**
3506 *      dev_unicast_delete      - Release secondary unicast address.
3507 *      @dev: device
3508 *      @addr: address to delete
3509 *      @alen: length of @addr
3510 *
3511 *      Release reference to a secondary unicast address and remove it
3512 *      from the device if the reference count drops to zero.
3513 *
3514 *      The caller must hold the rtnl_mutex.
3515 */
3516int dev_unicast_delete(struct net_device *dev, void *addr, int alen)
3517{
3518        int err;
3519
3520        ASSERT_RTNL();
3521
3522        netif_addr_lock_bh(dev);
3523        err = __dev_addr_delete(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3524        if (!err)
3525                __dev_set_rx_mode(dev);
3526        netif_addr_unlock_bh(dev);
3527        return err;
3528}
3529EXPORT_SYMBOL(dev_unicast_delete);
3530
3531/**
3532 *      dev_unicast_add         - add a secondary unicast address
3533 *      @dev: device
3534 *      @addr: address to add
3535 *      @alen: length of @addr
3536 *
3537 *      Add a secondary unicast address to the device or increase
3538 *      the reference count if it already exists.
3539 *
3540 *      The caller must hold the rtnl_mutex.
3541 */
3542int dev_unicast_add(struct net_device *dev, void *addr, int alen)
3543{
3544        int err;
3545
3546        ASSERT_RTNL();
3547
3548        netif_addr_lock_bh(dev);
3549        err = __dev_addr_add(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3550        if (!err)
3551                __dev_set_rx_mode(dev);
3552        netif_addr_unlock_bh(dev);
3553        return err;
3554}
3555EXPORT_SYMBOL(dev_unicast_add);
3556
3557int __dev_addr_sync(struct dev_addr_list **to, int *to_count,
3558                    struct dev_addr_list **from, int *from_count)
3559{
3560        struct dev_addr_list *da, *next;
3561        int err = 0;
3562
3563        da = *from;
3564        while (da != NULL) {
3565                next = da->next;
3566                if (!da->da_synced) {
3567                        err = __dev_addr_add(to, to_count,
3568                                             da->da_addr, da->da_addrlen, 0);
3569                        if (err < 0)
3570                                break;
3571                        da->da_synced = 1;
3572                        da->da_users++;
3573                } else if (da->da_users == 1) {
3574                        __dev_addr_delete(to, to_count,
3575                                          da->da_addr, da->da_addrlen, 0);
3576                        __dev_addr_delete(from, from_count,
3577                                          da->da_addr, da->da_addrlen, 0);
3578                }
3579                da = next;
3580        }
3581        return err;
3582}
3583
3584void __dev_addr_unsync(struct dev_addr_list **to, int *to_count,
3585                       struct dev_addr_list **from, int *from_count)
3586{
3587        struct dev_addr_list *da, *next;
3588
3589        da = *from;
3590        while (da != NULL) {
3591                next = da->next;
3592                if (da->da_synced) {
3593                        __dev_addr_delete(to, to_count,
3594                                          da->da_addr, da->da_addrlen, 0);
3595                        da->da_synced = 0;
3596                        __dev_addr_delete(from, from_count,
3597                                          da->da_addr, da->da_addrlen, 0);
3598                }
3599                da = next;
3600        }
3601}
3602
3603/**
3604 *      dev_unicast_sync - Synchronize device's unicast list to another device
3605 *      @to: destination device
3606 *      @from: source device
3607 *
3608 *      Add newly added addresses to the destination device and release
3609 *      addresses that have no users left. The source device must be
3610 *      locked by netif_tx_lock_bh.
3611 *
3612 *      This function is intended to be called from the dev->set_rx_mode
3613 *      function of layered software devices.
3614 */
3615int dev_unicast_sync(struct net_device *to, struct net_device *from)
3616{
3617        int err = 0;
3618
3619        netif_addr_lock_bh(to);
3620        err = __dev_addr_sync(&to->uc_list, &to->uc_count,
3621                              &from->uc_list, &from->uc_count);
3622        if (!err)
3623                __dev_set_rx_mode(to);
3624        netif_addr_unlock_bh(to);
3625        return err;
3626}
3627EXPORT_SYMBOL(dev_unicast_sync);
3628
3629/**
3630 *      dev_unicast_unsync - Remove synchronized addresses from the destination device
3631 *      @to: destination device
3632 *      @from: source device
3633 *
3634 *      Remove all addresses that were added to the destination device by
3635 *      dev_unicast_sync(). This function is intended to be called from the
3636 *      dev->stop function of layered software devices.
3637 */
3638void dev_unicast_unsync(struct net_device *to, struct net_device *from)
3639{
3640        netif_addr_lock_bh(from);
3641        netif_addr_lock(to);
3642
3643        __dev_addr_unsync(&to->uc_list, &to->uc_count,
3644                          &from->uc_list, &from->uc_count);
3645        __dev_set_rx_mode(to);
3646
3647        netif_addr_unlock(to);
3648        netif_addr_unlock_bh(from);
3649}
3650EXPORT_SYMBOL(dev_unicast_unsync);
3651
3652static void __dev_addr_discard(struct dev_addr_list **list)
3653{
3654        struct dev_addr_list *tmp;
3655
3656        while (*list != NULL) {
3657                tmp = *list;
3658                *list = tmp->next;
3659                if (tmp->da_users > tmp->da_gusers)
3660                        printk("__dev_addr_discard: address leakage! "
3661                               "da_users=%d\n", tmp->da_users);
3662                kfree(tmp);
3663        }
3664}
3665
3666static void dev_addr_discard(struct net_device *dev)
3667{
3668        netif_addr_lock_bh(dev);
3669
3670        __dev_addr_discard(&dev->uc_list);
3671        dev->uc_count = 0;
3672
3673        __dev_addr_discard(&dev->mc_list);
3674        dev->mc_count = 0;
3675
3676        netif_addr_unlock_bh(dev);
3677}
3678
3679/**
3680 *      dev_get_flags - get flags reported to userspace
3681 *      @dev: device
3682 *
3683 *      Get the combination of flag bits exported through APIs to userspace.
3684 */
3685unsigned dev_get_flags(const struct net_device *dev)
3686{
3687        unsigned flags;
3688
3689        flags = (dev->flags & ~(IFF_PROMISC |
3690                                IFF_ALLMULTI |
3691                                IFF_RUNNING |
3692                                IFF_LOWER_UP |
3693                                IFF_DORMANT)) |
3694                (dev->gflags & (IFF_PROMISC |
3695                                IFF_ALLMULTI));
3696
3697        if (netif_running(dev)) {
3698                if (netif_oper_up(dev))
3699                        flags |= IFF_RUNNING;
3700                if (netif_carrier_ok(dev))
3701                        flags |= IFF_LOWER_UP;
3702                if (netif_dormant(dev))
3703                        flags |= IFF_DORMANT;
3704        }
3705
3706        return flags;
3707}
3708
3709/**
3710 *      dev_change_flags - change device settings
3711 *      @dev: device
3712 *      @flags: device state flags
3713 *
3714 *      Change settings on device based state flags. The flags are
3715 *      in the userspace exported format.
3716 */
3717int dev_change_flags(struct net_device *dev, unsigned flags)
3718{
3719        int ret, changes;
3720        int old_flags = dev->flags;
3721
3722        ASSERT_RTNL();
3723
3724        /*
3725         *      Set the flags on our device.
3726         */
3727
3728        dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
3729                               IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
3730                               IFF_AUTOMEDIA)) |
3731                     (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
3732                                    IFF_ALLMULTI));
3733
3734        /*
3735         *      Load in the correct multicast list now the flags have changed.
3736         */
3737
3738        if ((old_flags ^ flags) & IFF_MULTICAST)
3739                dev_change_rx_flags(dev, IFF_MULTICAST);
3740
3741        dev_set_rx_mode(dev);
3742
3743        /*
3744         *      Have we downed the interface. We handle IFF_UP ourselves
3745         *      according to user attempts to set it, rather than blindly
3746         *      setting it.
3747         */
3748
3749        ret = 0;
3750        if ((old_flags ^ flags) & IFF_UP) {     /* Bit is different  ? */
3751                ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
3752
3753                if (!ret)
3754                        dev_set_rx_mode(dev);
3755        }
3756
3757        if (dev->flags & IFF_UP &&
3758            ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
3759                                          IFF_VOLATILE)))
3760                call_netdevice_notifiers(NETDEV_CHANGE, dev);
3761
3762        if ((flags ^ dev->gflags) & IFF_PROMISC) {
3763                int inc = (flags & IFF_PROMISC) ? +1 : -1;
3764                dev->gflags ^= IFF_PROMISC;
3765                dev_set_promiscuity(dev, inc);
3766        }
3767
3768        /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
3769           is important. Some (broken) drivers set IFF_PROMISC, when
3770           IFF_ALLMULTI is requested not asking us and not reporting.
3771         */
3772        if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
3773                int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
3774                dev->gflags ^= IFF_ALLMULTI;
3775                dev_set_allmulti(dev, inc);
3776        }
3777
3778        /* Exclude state transition flags, already notified */
3779        changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
3780        if (changes)
3781                rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
3782
3783        return ret;
3784}
3785
3786/**
3787 *      dev_set_mtu - Change maximum transfer unit
3788 *      @dev: device
3789 *      @new_mtu: new transfer unit
3790 *
3791 *      Change the maximum transfer size of the network device.
3792 */
3793int dev_set_mtu(struct net_device *dev, int new_mtu)
3794{
3795        const struct net_device_ops *ops = dev->netdev_ops;
3796        int err;
3797
3798        if (new_mtu == dev->mtu)
3799                return 0;
3800
3801        /*      MTU must be positive.    */
3802        if (new_mtu < 0)
3803                return -EINVAL;
3804
3805        if (!netif_device_present(dev))
3806                return -ENODEV;
3807
3808        err = 0;
3809        if (ops->ndo_change_mtu)
3810                err = ops->ndo_change_mtu(dev, new_mtu);
3811        else
3812                dev->mtu = new_mtu;
3813
3814        if (!err && dev->flags & IFF_UP)
3815                call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
3816        return err;
3817}
3818
3819/**
3820 *      dev_set_mac_address - Change Media Access Control Address
3821 *      @dev: device
3822 *      @sa: new address
3823 *
3824 *      Change the hardware (MAC) address of the device
3825 */
3826int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
3827{
3828        const struct net_device_ops *ops = dev->netdev_ops;
3829        int err;
3830
3831        if (!ops->ndo_set_mac_address)
3832                return -EOPNOTSUPP;
3833        if (sa->sa_family != dev->type)
3834                return -EINVAL;
3835        if (!netif_device_present(dev))
3836                return -ENODEV;
3837        err = ops->ndo_set_mac_address(dev, sa);
3838        if (!err)
3839                call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3840        return err;
3841}
3842
3843/*
3844 *      Perform the SIOCxIFxxx calls, inside read_lock(dev_base_lock)
3845 */
3846static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
3847{
3848        int err;
3849        struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3850
3851        if (!dev)
3852                return -ENODEV;
3853
3854        switch (cmd) {
3855                case SIOCGIFFLAGS:      /* Get interface flags */
3856                        ifr->ifr_flags = dev_get_flags(dev);
3857                        return 0;
3858
3859                case SIOCGIFMETRIC:     /* Get the metric on the interface
3860                                           (currently unused) */
3861                        ifr->ifr_metric = 0;
3862                        return 0;
3863
3864                case SIOCGIFMTU:        /* Get the MTU of a device */
3865                        ifr->ifr_mtu = dev->mtu;
3866                        return 0;
3867
3868                case SIOCGIFHWADDR:
3869                        if (!dev->addr_len)
3870                                memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
3871                        else
3872                                memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
3873                                       min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3874                        ifr->ifr_hwaddr.sa_family = dev->type;
3875                        return 0;
3876
3877                case SIOCGIFSLAVE:
3878                        err = -EINVAL;
3879                        break;
3880
3881                case SIOCGIFMAP:
3882                        ifr->ifr_map.mem_start = dev->mem_start;
3883                        ifr->ifr_map.mem_end   = dev->mem_end;
3884                        ifr->ifr_map.base_addr = dev->base_addr;
3885                        ifr->ifr_map.irq       = dev->irq;
3886                        ifr->ifr_map.dma       = dev->dma;
3887                        ifr->ifr_map.port      = dev->if_port;
3888                        return 0;
3889
3890                case SIOCGIFINDEX:
3891                        ifr->ifr_ifindex = dev->ifindex;
3892                        return 0;
3893
3894                case SIOCGIFTXQLEN:
3895                        ifr->ifr_qlen = dev->tx_queue_len;
3896                        return 0;
3897
3898                default:
3899                        /* dev_ioctl() should ensure this case
3900                         * is never reached
3901                         */
3902                        WARN_ON(1);
3903                        err = -EINVAL;
3904                        break;
3905
3906        }
3907        return err;
3908}
3909
3910/*
3911 *      Perform the SIOCxIFxxx calls, inside rtnl_lock()
3912 */
3913static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
3914{
3915        int err;
3916        struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3917        const struct net_device_ops *ops;
3918
3919        if (!dev)
3920                return -ENODEV;
3921
3922        ops = dev->netdev_ops;
3923
3924        switch (cmd) {
3925                case SIOCSIFFLAGS:      /* Set interface flags */
3926                        return dev_change_flags(dev, ifr->ifr_flags);
3927
3928                case SIOCSIFMETRIC:     /* Set the metric on the interface
3929                                           (currently unused) */
3930                        return -EOPNOTSUPP;
3931
3932                case SIOCSIFMTU:        /* Set the MTU of a device */
3933                        return dev_set_mtu(dev, ifr->ifr_mtu);
3934
3935                case SIOCSIFHWADDR:
3936                        return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
3937
3938                case SIOCSIFHWBROADCAST:
3939                        if (ifr->ifr_hwaddr.sa_family != dev->type)
3940                                return -EINVAL;
3941                        memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
3942                               min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3943                        call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3944                        return 0;
3945
3946                case SIOCSIFMAP:
3947                        if (ops->ndo_set_config) {
3948                                if (!netif_device_present(dev))
3949                                        return -ENODEV;
3950                                return ops->ndo_set_config(dev, &ifr->ifr_map);
3951                        }
3952                        return -EOPNOTSUPP;
3953
3954                case SIOCADDMULTI:
3955                        if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
3956                            ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3957                                return -EINVAL;
3958                        if (!netif_device_present(dev))
3959                                return -ENODEV;
3960                        return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
3961                                          dev->addr_len, 1);
3962
3963                case SIOCDELMULTI:
3964                        if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
3965                            ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3966                                return -EINVAL;
3967                        if (!netif_device_present(dev))
3968                                return -ENODEV;
3969                        return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
3970                                             dev->addr_len, 1);
3971
3972                case SIOCSIFTXQLEN:
3973                        if (ifr->ifr_qlen < 0)
3974                                return -EINVAL;
3975                        dev->tx_queue_len = ifr->ifr_qlen;
3976                        return 0;
3977
3978                case SIOCSIFNAME:
3979                        ifr->ifr_newname[IFNAMSIZ-1] = '\0';
3980                        return dev_change_name(dev, ifr->ifr_newname);
3981
3982                /*
3983                 *      Unknown or private ioctl
3984                 */
3985
3986                default:
3987                        if ((cmd >= SIOCDEVPRIVATE &&
3988                            cmd <= SIOCDEVPRIVATE + 15) ||
3989                            cmd == SIOCBONDENSLAVE ||
3990                            cmd == SIOCBONDRELEASE ||
3991                            cmd == SIOCBONDSETHWADDR ||
3992                            cmd == SIOCBONDSLAVEINFOQUERY ||
3993                            cmd == SIOCBONDINFOQUERY ||
3994                            cmd == SIOCBONDCHANGEACTIVE ||
3995                            cmd == SIOCGMIIPHY ||
3996                            cmd == SIOCGMIIREG ||
3997                            cmd == SIOCSMIIREG ||
3998                            cmd == SIOCBRADDIF ||
3999                            cmd == SIOCBRDELIF ||
4000                            cmd == SIOCSHWTSTAMP ||
4001                            cmd == SIOCWANDEV) {
4002                                err = -EOPNOTSUPP;
4003                                if (ops->ndo_do_ioctl) {
4004                                        if (netif_device_present(dev))
4005                                                err = ops->ndo_do_ioctl(dev, ifr, cmd);
4006                                        else
4007                                                err = -ENODEV;
4008                                }
4009                        } else
4010                                err = -EINVAL;
4011
4012        }
4013        return err;
4014}
4015
4016/*
4017 *      This function handles all "interface"-type I/O control requests. The actual
4018 *      'doing' part of this is dev_ifsioc above.
4019 */
4020
4021/**
4022 *      dev_ioctl       -       network device ioctl
4023 *      @net: the applicable net namespace
4024 *      @cmd: command to issue
4025 *      @arg: pointer to a struct ifreq in user space
4026 *
4027 *      Issue ioctl functions to devices. This is normally called by the
4028 *      user space syscall interfaces but can sometimes be useful for
4029 *      other purposes. The return value is the return from the syscall if
4030 *      positive or a negative errno code on error.
4031 */
4032
4033int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
4034{
4035        struct ifreq ifr;
4036        int ret;
4037        char *colon;
4038
4039        /* One special case: SIOCGIFCONF takes ifconf argument
4040           and requires shared lock, because it sleeps writing
4041           to user space.
4042         */
4043
4044        if (cmd == SIOCGIFCONF) {
4045                rtnl_lock();
4046                ret = dev_ifconf(net, (char __user *) arg);
4047                rtnl_unlock();
4048                return ret;
4049        }
4050        if (cmd == SIOCGIFNAME)
4051                return dev_ifname(net, (struct ifreq __user *)arg);
4052
4053        if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
4054                return -EFAULT;
4055
4056        ifr.ifr_name[IFNAMSIZ-1] = 0;
4057
4058        colon = strchr(ifr.ifr_name, ':');
4059        if (colon)
4060                *colon = 0;
4061
4062        /*
4063         *      See which interface the caller is talking about.
4064         */
4065
4066        switch (cmd) {
4067                /*
4068                 *      These ioctl calls:
4069                 *      - can be done by all.
4070                 *      - atomic and do not require locking.
4071                 *      - return a value
4072                 */
4073                case SIOCGIFFLAGS:
4074                case SIOCGIFMETRIC:
4075                case SIOCGIFMTU:
4076                case SIOCGIFHWADDR:
4077                case SIOCGIFSLAVE:
4078                case SIOCGIFMAP:
4079                case SIOCGIFINDEX:
4080                case SIOCGIFTXQLEN:
4081                        dev_load(net, ifr.ifr_name);
4082                        read_lock(&dev_base_lock);
4083                        ret = dev_ifsioc_locked(net, &ifr, cmd);
4084                        read_unlock(&dev_base_lock);
4085                        if (!ret) {
4086                                if (colon)
4087                                        *colon = ':';
4088                                if (copy_to_user(arg, &ifr,
4089                                                 sizeof(struct ifreq)))
4090                                        ret = -EFAULT;
4091                        }
4092                        return ret;
4093
4094                case SIOCETHTOOL:
4095                        dev_load(net, ifr.ifr_name);
4096                        rtnl_lock();
4097                        ret = dev_ethtool(net, &ifr);
4098                        rtnl_unlock();
4099                        if (!ret) {
4100                                if (colon)
4101                                        *colon = ':';
4102                                if (copy_to_user(arg, &ifr,
4103                                                 sizeof(struct ifreq)))
4104                                        ret = -EFAULT;
4105                        }
4106                        return ret;
4107
4108                /*
4109                 *      These ioctl calls:
4110                 *      - require superuser power.
4111                 *      - require strict serialization.
4112                 *      - return a value
4113                 */
4114                case SIOCGMIIPHY:
4115                case SIOCGMIIREG:
4116                case SIOCSIFNAME:
4117                        if (!capable(CAP_NET_ADMIN))
4118                                return -EPERM;
4119                        dev_load(net, ifr.ifr_name);
4120                        rtnl_lock();
4121                        ret = dev_ifsioc(net, &ifr, cmd);
4122                        rtnl_unlock();
4123                        if (!ret) {
4124                                if (colon)
4125                                        *colon = ':';
4126                                if (copy_to_user(arg, &ifr,
4127                                                 sizeof(struct ifreq)))
4128                                        ret = -EFAULT;
4129                        }
4130                        return ret;
4131
4132                /*
4133                 *      These ioctl calls:
4134                 *      - require superuser power.
4135                 *      - require strict serialization.
4136                 *      - do not return a value
4137                 */
4138                case SIOCSIFFLAGS:
4139                case SIOCSIFMETRIC:
4140                case SIOCSIFMTU:
4141                case SIOCSIFMAP:
4142                case SIOCSIFHWADDR:
4143                case SIOCSIFSLAVE:
4144                case SIOCADDMULTI:
4145                case SIOCDELMULTI:
4146                case SIOCSIFHWBROADCAST:
4147                case SIOCSIFTXQLEN:
4148                case SIOCSMIIREG:
4149                case SIOCBONDENSLAVE:
4150                case SIOCBONDRELEASE:
4151                case SIOCBONDSETHWADDR:
4152                case SIOCBONDCHANGEACTIVE:
4153                case SIOCBRADDIF:
4154                case SIOCBRDELIF:
4155                case SIOCSHWTSTAMP:
4156                        if (!capable(CAP_NET_ADMIN))
4157                                return -EPERM;
4158                        /* fall through */
4159                case SIOCBONDSLAVEINFOQUERY:
4160                case SIOCBONDINFOQUERY:
4161                        dev_load(net, ifr.ifr_name);
4162                        rtnl_lock();
4163                        ret = dev_ifsioc(net, &ifr, cmd);
4164                        rtnl_unlock();
4165                        return ret;
4166
4167                case SIOCGIFMEM:
4168                        /* Get the per device memory space. We can add this but
4169                         * currently do not support it */
4170                case SIOCSIFMEM:
4171                        /* Set the per device memory buffer space.
4172                         * Not applicable in our case */
4173                case SIOCSIFLINK:
4174                        return -EINVAL;
4175
4176                /*
4177                 *      Unknown or private ioctl.
4178                 */
4179                default:
4180                        if (cmd == SIOCWANDEV ||
4181                            (cmd >= SIOCDEVPRIVATE &&
4182                             cmd <= SIOCDEVPRIVATE + 15)) {
4183                                dev_load(net, ifr.ifr_name);
4184                                rtnl_lock();
4185                                ret = dev_ifsioc(net, &ifr, cmd);
4186                                rtnl_unlock();
4187                                if (!ret && copy_to_user(arg, &ifr,
4188                                                         sizeof(struct ifreq)))
4189                                        ret = -EFAULT;
4190                                return ret;
4191                        }
4192                        /* Take care of Wireless Extensions */
4193                        if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
4194                                return wext_handle_ioctl(net, &ifr, cmd, arg);
4195                        return -EINVAL;
4196        }
4197}
4198
4199
4200/**
4201 *      dev_new_index   -       allocate an ifindex
4202 *      @net: the applicable net namespace
4203 *
4204 *      Returns a suitable unique value for a new device interface
4205 *      number.  The caller must hold the rtnl semaphore or the
4206 *      dev_base_lock to be sure it remains unique.
4207 */
4208static int dev_new_index(struct net *net)
4209{
4210        static int ifindex;
4211        for (;;) {
4212                if (++ifindex <= 0)
4213                        ifindex = 1;
4214                if (!__dev_get_by_index(net, ifindex))
4215                        return ifindex;
4216        }
4217}
4218
4219/* Delayed registration/unregisteration */
4220static LIST_HEAD(net_todo_list);
4221
4222static void net_set_todo(struct net_device *dev)
4223{
4224        list_add_tail(&dev->todo_list, &net_todo_list);
4225}
4226
4227static void rollback_registered(struct net_device *dev)
4228{
4229        BUG_ON(dev_boot_phase);
4230        ASSERT_RTNL();
4231
4232        /* Some devices call without registering for initialization unwind. */
4233        if (dev->reg_state == NETREG_UNINITIALIZED) {
4234                printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
4235                                  "was registered\n", dev->name, dev);
4236
4237                WARN_ON(1);
4238                return;
4239        }
4240
4241        BUG_ON(dev->reg_state != NETREG_REGISTERED);
4242
4243        /* If device is running, close it first. */
4244        dev_close(dev);
4245
4246        /* And unlink it from device chain. */
4247        unlist_netdevice(dev);
4248
4249        dev->reg_state = NETREG_UNREGISTERING;
4250
4251        synchronize_net();
4252
4253        /* Shutdown queueing discipline. */
4254        dev_shutdown(dev);
4255
4256
4257        /* Notify protocols, that we are about to destroy
4258           this device. They should clean all the things.
4259        */
4260        call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4261
4262        /*
4263         *      Flush the unicast and multicast chains
4264         */
4265        dev_addr_discard(dev);
4266
4267        if (dev->netdev_ops->ndo_uninit)
4268                dev->netdev_ops->ndo_uninit(dev);
4269
4270        /* Notifier chain MUST detach us from master device. */
4271        WARN_ON(dev->master);
4272
4273        /* Remove entries from kobject tree */
4274        netdev_unregister_kobject(dev);
4275
4276        synchronize_net();
4277
4278        dev_put(dev);
4279}
4280
4281static void __netdev_init_queue_locks_one(struct net_device *dev,
4282                                          struct netdev_queue *dev_queue,
4283                                          void *_unused)
4284{
4285        spin_lock_init(&dev_queue->_xmit_lock);
4286        netdev_set_xmit_lockdep_class(&dev_queue->_xmit_lock, dev->type);
4287        dev_queue->xmit_lock_owner = -1;
4288}
4289
4290static void netdev_init_queue_locks(struct net_device *dev)
4291{
4292        netdev_for_each_tx_queue(dev, __netdev_init_queue_locks_one, NULL);
4293        __netdev_init_queue_locks_one(dev, &dev->rx_queue, NULL);
4294}
4295
4296unsigned long netdev_fix_features(unsigned long features, const char *name)
4297{
4298        /* Fix illegal SG+CSUM combinations. */
4299        if ((features & NETIF_F_SG) &&
4300            !(features & NETIF_F_ALL_CSUM)) {
4301                if (name)
4302                        printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no "
4303                               "checksum feature.\n", name);
4304                features &= ~NETIF_F_SG;
4305        }
4306
4307        /* TSO requires that SG is present as well. */
4308        if ((features & NETIF_F_TSO) && !(features & NETIF_F_SG)) {
4309                if (name)
4310                        printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no "
4311                               "SG feature.\n", name);
4312                features &= ~NETIF_F_TSO;
4313        }
4314
4315        if (features & NETIF_F_UFO) {
4316                if (!(features & NETIF_F_GEN_CSUM)) {
4317                        if (name)
4318                                printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
4319                                       "since no NETIF_F_HW_CSUM feature.\n",
4320                                       name);
4321                        features &= ~NETIF_F_UFO;
4322                }
4323
4324                if (!(features & NETIF_F_SG)) {
4325                        if (name)
4326                                printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
4327                                       "since no NETIF_F_SG feature.\n", name);
4328                        features &= ~NETIF_F_UFO;
4329                }
4330        }
4331
4332        return features;
4333}
4334EXPORT_SYMBOL(netdev_fix_features);
4335
4336/* Some devices need to (re-)set their netdev_ops inside
4337 * ->init() or similar.  If that happens, we have to setup
4338 * the compat pointers again.
4339 */
4340void netdev_resync_ops(struct net_device *dev)
4341{
4342#ifdef CONFIG_COMPAT_NET_DEV_OPS
4343        const struct net_device_ops *ops = dev->netdev_ops;
4344
4345        dev->init = ops->ndo_init;
4346        dev->uninit = ops->ndo_uninit;
4347        dev->open = ops->ndo_open;
4348        dev->change_rx_flags = ops->ndo_change_rx_flags;
4349        dev->set_rx_mode = ops->ndo_set_rx_mode;
4350        dev->set_multicast_list = ops->ndo_set_multicast_list;
4351        dev->set_mac_address = ops->ndo_set_mac_address;
4352        dev->validate_addr = ops->ndo_validate_addr;
4353        dev->do_ioctl = ops->ndo_do_ioctl;
4354        dev->set_config = ops->ndo_set_config;
4355        dev->change_mtu = ops->ndo_change_mtu;
4356        dev->neigh_setup = ops->ndo_neigh_setup;
4357        dev->tx_timeout = ops->ndo_tx_timeout;
4358        dev->get_stats = ops->ndo_get_stats;
4359        dev->vlan_rx_register = ops->ndo_vlan_rx_register;
4360        dev->vlan_rx_add_vid = ops->ndo_vlan_rx_add_vid;
4361        dev->vlan_rx_kill_vid = ops->ndo_vlan_rx_kill_vid;
4362#ifdef CONFIG_NET_POLL_CONTROLLER
4363        dev->poll_controller = ops->ndo_poll_controller;
4364#endif
4365#endif
4366}
4367EXPORT_SYMBOL(netdev_resync_ops);
4368
4369/**
4370 *      register_netdevice      - register a network device
4371 *      @dev: device to register
4372 *
4373 *      Take a completed network device structure and add it to the kernel
4374 *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
4375 *      chain. 0 is returned on success. A negative errno code is returned
4376 *      on a failure to set up the device, or if the name is a duplicate.
4377 *
4378 *      Callers must hold the rtnl semaphore. You may want
4379 *      register_netdev() instead of this.
4380 *
4381 *      BUGS:
4382 *      The locking appears insufficient to guarantee two parallel registers
4383 *      will not get the same name.
4384 */
4385
4386int register_netdevice(struct net_device *dev)
4387{
4388        struct hlist_head *head;
4389        struct hlist_node *p;
4390        int ret;
4391        struct net *net = dev_net(dev);
4392
4393        BUG_ON(dev_boot_phase);
4394        ASSERT_RTNL();
4395
4396        might_sleep();
4397
4398        /* When net_device's are persistent, this will be fatal. */
4399        BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
4400        BUG_ON(!net);
4401
4402        spin_lock_init(&dev->addr_list_lock);
4403        netdev_set_addr_lockdep_class(dev);
4404        netdev_init_queue_locks(dev);
4405
4406        dev->iflink = -1;
4407
4408#ifdef CONFIG_COMPAT_NET_DEV_OPS
4409        /* Netdevice_ops API compatibility support.
4410         * This is temporary until all network devices are converted.
4411         */
4412        if (dev->netdev_ops) {
4413                netdev_resync_ops(dev);
4414        } else {
4415                char drivername[64];
4416                pr_info("%s (%s): not using net_device_ops yet\n",
4417                        dev->name, netdev_drivername(dev, drivername, 64));
4418
4419                /* This works only because net_device_ops and the
4420                   compatibility structure are the same. */
4421                dev->netdev_ops = (void *) &(dev->init);
4422        }
4423#endif
4424
4425        /* Init, if this function is available */
4426        if (dev->netdev_ops->ndo_init) {
4427                ret = dev->netdev_ops->ndo_init(dev);
4428                if (ret) {
4429                        if (ret > 0)
4430                                ret = -EIO;
4431                        goto out;
4432                }
4433        }
4434
4435        if (!dev_valid_name(dev->name)) {
4436                ret = -EINVAL;
4437                goto err_uninit;
4438        }
4439
4440        dev->ifindex = dev_new_index(net);
4441        if (dev->iflink == -1)
4442                dev->iflink = dev->ifindex;
4443
4444        /* Check for existence of name */
4445        head = dev_name_hash(net, dev->name);
4446        hlist_for_each(p, head) {
4447                struct net_device *d
4448                        = hlist_entry(p, struct net_device, name_hlist);
4449                if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
4450                        ret = -EEXIST;
4451                        goto err_uninit;
4452                }
4453        }
4454
4455        /* Fix illegal checksum combinations */
4456        if ((dev->features & NETIF_F_HW_CSUM) &&
4457            (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
4458                printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
4459                       dev->name);
4460                dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
4461        }
4462
4463        if ((dev->features & NETIF_F_NO_CSUM) &&
4464            (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
4465                printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
4466                       dev->name);
4467                dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
4468        }
4469
4470        dev->features = netdev_fix_features(dev->features, dev->name);
4471
4472        /* Enable software GSO if SG is supported. */
4473        if (dev->features & NETIF_F_SG)
4474                dev->features |= NETIF_F_GSO;
4475
4476        netdev_initialize_kobject(dev);
4477        ret = netdev_register_kobject(dev);
4478        if (ret)
4479                goto err_uninit;
4480        dev->reg_state = NETREG_REGISTERED;
4481
4482        /*
4483         *      Default initial state at registry is that the
4484         *      device is present.
4485         */
4486
4487        set_bit(__LINK_STATE_PRESENT, &dev->state);
4488
4489        dev_init_scheduler(dev);
4490        dev_hold(dev);
4491        list_netdevice(dev);
4492
4493        /* Notify protocols, that a new device appeared. */
4494        ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
4495        ret = notifier_to_errno(ret);
4496        if (ret) {
4497                rollback_registered(dev);
4498                dev->reg_state = NETREG_UNREGISTERED;
4499        }
4500
4501out:
4502        return ret;
4503
4504err_uninit:
4505        if (dev->netdev_ops->ndo_uninit)
4506                dev->netdev_ops->ndo_uninit(dev);
4507        goto out;
4508}
4509
4510/**
4511 *      init_dummy_netdev       - init a dummy network device for NAPI
4512 *      @dev: device to init
4513 *
4514 *      This takes a network device structure and initialize the minimum
4515 *      amount of fields so it can be used to schedule NAPI polls without
4516 *      registering a full blown interface. This is to be used by drivers
4517 *      that need to tie several hardware interfaces to a single NAPI
4518 *      poll scheduler due to HW limitations.
4519 */
4520int init_dummy_netdev(struct net_device *dev)
4521{
4522        /* Clear everything. Note we don't initialize spinlocks
4523         * are they aren't supposed to be taken by any of the
4524         * NAPI code and this dummy netdev is supposed to be
4525         * only ever used for NAPI polls
4526         */
4527        memset(dev, 0, sizeof(struct net_device));
4528
4529        /* make sure we BUG if trying to hit standard
4530         * register/unregister code path
4531         */
4532        dev->reg_state = NETREG_DUMMY;
4533
4534        /* initialize the ref count */
4535        atomic_set(&dev->refcnt, 1);
4536
4537        /* NAPI wants this */
4538        INIT_LIST_HEAD(&dev->napi_list);
4539
4540        /* a dummy interface is started by default */
4541        set_bit(__LINK_STATE_PRESENT, &dev->state);
4542        set_bit(__LINK_STATE_START, &dev->state);
4543
4544        return 0;
4545}
4546EXPORT_SYMBOL_GPL(init_dummy_netdev);
4547
4548
4549/**
4550 *      register_netdev - register a network device
4551 *      @dev: device to register
4552 *
4553 *      Take a completed network device structure and add it to the kernel
4554 *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
4555 *      chain. 0 is returned on success. A negative errno code is returned
4556 *      on a failure to set up the device, or if the name is a duplicate.
4557 *
4558 *      This is a wrapper around register_netdevice that takes the rtnl semaphore
4559 *      and expands the device name if you passed a format string to
4560 *      alloc_netdev.
4561 */
4562int register_netdev(struct net_device *dev)
4563{
4564        int err;
4565
4566        rtnl_lock();
4567
4568        /*
4569         * If the name is a format string the caller wants us to do a
4570         * name allocation.
4571         */
4572        if (strchr(dev->name, '%')) {
4573                err = dev_alloc_name(dev, dev->name);
4574                if (err < 0)
4575                        goto out;
4576        }
4577
4578        err = register_netdevice(dev);
4579out:
4580        rtnl_unlock();
4581        return err;
4582}
4583EXPORT_SYMBOL(register_netdev);
4584
4585/*
4586 * netdev_wait_allrefs - wait until all references are gone.
4587 *
4588 * This is called when unregistering network devices.
4589 *
4590 * Any protocol or device that holds a reference should register
4591 * for netdevice notification, and cleanup and put back the
4592 * reference if they receive an UNREGISTER event.
4593 * We can get stuck here if buggy protocols don't correctly
4594 * call dev_put.
4595 */
4596static void netdev_wait_allrefs(struct net_device *dev)
4597{
4598        unsigned long rebroadcast_time, warning_time;
4599
4600        rebroadcast_time = warning_time = jiffies;
4601        while (atomic_read(&dev->refcnt) != 0) {
4602                if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
4603                        rtnl_lock();
4604
4605                        /* Rebroadcast unregister notification */
4606                        call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4607
4608                        if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
4609                                     &dev->state)) {
4610                                /* We must not have linkwatch events
4611                                 * pending on unregister. If this
4612                                 * happens, we simply run the queue
4613                                 * unscheduled, resulting in a noop
4614                                 * for this device.
4615                                 */
4616                                linkwatch_run_queue();
4617                        }
4618
4619                        __rtnl_unlock();
4620
4621                        rebroadcast_time = jiffies;
4622                }
4623
4624                msleep(250);
4625
4626                if (time_after(jiffies, warning_time + 10 * HZ)) {
4627                        printk(KERN_EMERG "unregister_netdevice: "
4628                               "waiting for %s to become free. Usage "
4629                               "count = %d\n",
4630                               dev->name, atomic_read(&dev->refcnt));
4631                        warning_time = jiffies;
4632                }
4633        }
4634}
4635
4636/* The sequence is:
4637 *
4638 *      rtnl_lock();
4639 *      ...
4640 *      register_netdevice(x1);
4641 *      register_netdevice(x2);
4642 *      ...
4643 *      unregister_netdevice(y1);
4644 *      unregister_netdevice(y2);
4645 *      ...
4646 *      rtnl_unlock();
4647 *      free_netdev(y1);
4648 *      free_netdev(y2);
4649 *
4650 * We are invoked by rtnl_unlock().
4651 * This allows us to deal with problems:
4652 * 1) We can delete sysfs objects which invoke hotplug
4653 *    without deadlocking with linkwatch via keventd.
4654 * 2) Since we run with the RTNL semaphore not held, we can sleep
4655 *    safely in order to wait for the netdev refcnt to drop to zero.
4656 *
4657 * We must not return until all unregister events added during
4658 * the interval the lock was held have been completed.
4659 */
4660void netdev_run_todo(void)
4661{
4662        struct list_head list;
4663
4664        /* Snapshot list, allow later requests */
4665        list_replace_init(&net_todo_list, &list);
4666
4667        __rtnl_unlock();
4668
4669        while (!list_empty(&list)) {
4670                struct net_device *dev
4671                        = list_entry(list.next, struct net_device, todo_list);
4672                list_del(&dev->todo_list);
4673
4674                if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
4675                        printk(KERN_ERR "network todo '%s' but state %d\n",
4676                               dev->name, dev->reg_state);
4677                        dump_stack();
4678                        continue;
4679                }
4680
4681                dev->reg_state = NETREG_UNREGISTERED;
4682
4683                on_each_cpu(flush_backlog, dev, 1);
4684
4685                netdev_wait_allrefs(dev);
4686
4687                /* paranoia */
4688                BUG_ON(atomic_read(&dev->refcnt));
4689                WARN_ON(dev->ip_ptr);
4690                WARN_ON(dev->ip6_ptr);
4691                WARN_ON(dev->dn_ptr);
4692
4693                if (dev->destructor)
4694                        dev->destructor(dev);
4695
4696                /* Free network device */
4697                kobject_put(&dev->dev.kobj);
4698        }
4699}
4700
4701/**
4702 *      dev_get_stats   - get network device statistics
4703 *      @dev: device to get statistics from
4704 *
4705 *      Get network statistics from device. The device driver may provide
4706 *      its own method by setting dev->netdev_ops->get_stats; otherwise
4707 *      the internal statistics structure is used.
4708 */
4709const struct net_device_stats *dev_get_stats(struct net_device *dev)
4710 {
4711        const struct net_device_ops *ops = dev->netdev_ops;
4712
4713        if (ops->ndo_get_stats)
4714                return ops->ndo_get_stats(dev);
4715        else
4716                return &dev->stats;
4717}
4718EXPORT_SYMBOL(dev_get_stats);
4719
4720static void netdev_init_one_queue(struct net_device *dev,
4721                                  struct netdev_queue *queue,
4722                                  void *_unused)
4723{
4724        queue->dev = dev;
4725}
4726
4727static void netdev_init_queues(struct net_device *dev)
4728{
4729        netdev_init_one_queue(dev, &dev->rx_queue, NULL);
4730        netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
4731        spin_lock_init(&dev->tx_global_lock);
4732}
4733
4734/**
4735 *      alloc_netdev_mq - allocate network device
4736 *      @sizeof_priv:   size of private data to allocate space for
4737 *      @name:          device name format string
4738 *      @setup:         callback to initialize device
4739 *      @queue_count:   the number of subqueues to allocate
4740 *
4741 *      Allocates a struct net_device with private data area for driver use
4742 *      and performs basic initialization.  Also allocates subquue structs
4743 *      for each queue on the device at the end of the netdevice.
4744 */
4745struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
4746                void (*setup)(struct net_device *), unsigned int queue_count)
4747{
4748        struct netdev_queue *tx;
4749        struct net_device *dev;
4750        size_t alloc_size;
4751        void *p;
4752
4753        BUG_ON(strlen(name) >= sizeof(dev->name));
4754
4755        alloc_size = sizeof(struct net_device);
4756        if (sizeof_priv) {
4757                /* ensure 32-byte alignment of private area */
4758                alloc_size = (alloc_size + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
4759                alloc_size += sizeof_priv;
4760        }
4761        /* ensure 32-byte alignment of whole construct */
4762        alloc_size += NETDEV_ALIGN_CONST;
4763
4764        p = kzalloc(alloc_size, GFP_KERNEL);
4765        if (!p) {
4766                printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
4767                return NULL;
4768        }
4769
4770        tx = kcalloc(queue_count, sizeof(struct netdev_queue), GFP_KERNEL);
4771        if (!tx) {
4772                printk(KERN_ERR "alloc_netdev: Unable to allocate "
4773                       "tx qdiscs.\n");
4774                kfree(p);
4775                return NULL;
4776        }
4777
4778        dev = (struct net_device *)
4779                (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
4780        dev->padded = (char *)dev - (char *)p;
4781        dev_net_set(dev, &init_net);
4782
4783        dev->_tx = tx;
4784        dev->num_tx_queues = queue_count;
4785        dev->real_num_tx_queues = queue_count;
4786
4787        dev->gso_max_size = GSO_MAX_SIZE;
4788
4789        netdev_init_queues(dev);
4790
4791        INIT_LIST_HEAD(&dev->napi_list);
4792        setup(dev);
4793        strcpy(dev->name, name);
4794        return dev;
4795}
4796EXPORT_SYMBOL(alloc_netdev_mq);
4797
4798/**
4799 *      free_netdev - free network device
4800 *      @dev: device
4801 *
4802 *      This function does the last stage of destroying an allocated device
4803 *      interface. The reference to the device object is released.
4804 *      If this is the last reference then it will be freed.
4805 */
4806void free_netdev(struct net_device *dev)
4807{
4808        struct napi_struct *p, *n;
4809
4810        release_net(dev_net(dev));
4811
4812        kfree(dev->_tx);
4813
4814        list_for_each_entry_safe(p, n, &dev->napi_list, dev_list)
4815                netif_napi_del(p);
4816
4817        /*  Compatibility with error handling in drivers */
4818        if (dev->reg_state == NETREG_UNINITIALIZED) {
4819                kfree((char *)dev - dev->padded);
4820                return;
4821        }
4822
4823        BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
4824        dev->reg_state = NETREG_RELEASED;
4825
4826        /* will free via device release */
4827        put_device(&dev->dev);
4828}
4829
4830/**
4831 *      synchronize_net -  Synchronize with packet receive processing
4832 *
4833 *      Wait for packets currently being received to be done.
4834 *      Does not block later packets from starting.
4835 */
4836void synchronize_net(void)
4837{
4838        might_sleep();
4839        synchronize_rcu();
4840}
4841
4842/**
4843 *      unregister_netdevice - remove device from the kernel
4844 *      @dev: device
4845 *
4846 *      This function shuts down a device interface and removes it
4847 *      from the kernel tables.
4848 *
4849 *      Callers must hold the rtnl semaphore.  You may want
4850 *      unregister_netdev() instead of this.
4851 */
4852
4853void unregister_netdevice(struct net_device *dev)
4854{
4855        ASSERT_RTNL();
4856
4857        rollback_registered(dev);
4858        /* Finish processing unregister after unlock */
4859        net_set_todo(dev);
4860}
4861
4862/**
4863 *      unregister_netdev - remove device from the kernel
4864 *      @dev: device
4865 *
4866 *      This function shuts down a device interface and removes it
4867 *      from the kernel tables.
4868 *
4869 *      This is just a wrapper for unregister_netdevice that takes
4870 *      the rtnl semaphore.  In general you want to use this and not
4871 *      unregister_netdevice.
4872 */
4873void unregister_netdev(struct net_device *dev)
4874{
4875        rtnl_lock();
4876        unregister_netdevice(dev);
4877        rtnl_unlock();
4878}
4879
4880EXPORT_SYMBOL(unregister_netdev);
4881
4882/**
4883 *      dev_change_net_namespace - move device to different nethost namespace
4884 *      @dev: device
4885 *      @net: network namespace
4886 *      @pat: If not NULL name pattern to try if the current device name
4887 *            is already taken in the destination network namespace.
4888 *
4889 *      This function shuts down a device interface and moves it
4890 *      to a new network namespace. On success 0 is returned, on
4891 *      a failure a netagive errno code is returned.
4892 *
4893 *      Callers must hold the rtnl semaphore.
4894 */
4895
4896int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
4897{
4898        char buf[IFNAMSIZ];
4899        const char *destname;
4900        int err;
4901
4902        ASSERT_RTNL();
4903
4904        /* Don't allow namespace local devices to be moved. */
4905        err = -EINVAL;
4906        if (dev->features & NETIF_F_NETNS_LOCAL)
4907                goto out;
4908
4909#ifdef CONFIG_SYSFS
4910        /* Don't allow real devices to be moved when sysfs
4911         * is enabled.
4912         */
4913        err = -EINVAL;
4914        if (dev->dev.parent)
4915                goto out;
4916#endif
4917
4918        /* Ensure the device has been registrered */
4919        err = -EINVAL;
4920        if (dev->reg_state != NETREG_REGISTERED)
4921                goto out;
4922
4923        /* Get out if there is nothing todo */
4924        err = 0;
4925        if (net_eq(dev_net(dev), net))
4926                goto out;
4927
4928        /* Pick the destination device name, and ensure
4929         * we can use it in the destination network namespace.
4930         */
4931        err = -EEXIST;
4932        destname = dev->name;
4933        if (__dev_get_by_name(net, destname)) {
4934                /* We get here if we can't use the current device name */
4935                if (!pat)
4936                        goto out;
4937                if (!dev_valid_name(pat))
4938                        goto out;
4939                if (strchr(pat, '%')) {
4940                        if (__dev_alloc_name(net, pat, buf) < 0)
4941                                goto out;
4942                        destname = buf;
4943                } else
4944                        destname = pat;
4945                if (__dev_get_by_name(net, destname))
4946                        goto out;
4947        }
4948
4949        /*
4950         * And now a mini version of register_netdevice unregister_netdevice.
4951         */
4952
4953        /* If device is running close it first. */
4954        dev_close(dev);
4955
4956        /* And unlink it from device chain */
4957        err = -ENODEV;
4958        unlist_netdevice(dev);
4959
4960        synchronize_net();
4961
4962        /* Shutdown queueing discipline. */
4963        dev_shutdown(dev);
4964
4965        /* Notify protocols, that we are about to destroy
4966           this device. They should clean all the things.
4967        */
4968        call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4969
4970        /*
4971         *      Flush the unicast and multicast chains
4972         */
4973        dev_addr_discard(dev);
4974
4975        netdev_unregister_kobject(dev);
4976
4977        /* Actually switch the network namespace */
4978        dev_net_set(dev, net);
4979
4980        /* Assign the new device name */
4981        if (destname != dev->name)
4982                strcpy(dev->name, destname);
4983
4984        /* If there is an ifindex conflict assign a new one */
4985        if (__dev_get_by_index(net, dev->ifindex)) {
4986                int iflink = (dev->iflink == dev->ifindex);
4987                dev->ifindex = dev_new_index(net);
4988                if (iflink)
4989                        dev->iflink = dev->ifindex;
4990        }
4991
4992        /* Fixup kobjects */
4993        err = netdev_register_kobject(dev);
4994        WARN_ON(err);
4995
4996        /* Add the device back in the hashes */
4997        list_netdevice(dev);
4998
4999        /* Notify protocols, that a new device appeared. */
5000        call_netdevice_notifiers(NETDEV_REGISTER, dev);
5001
5002        synchronize_net();
5003        err = 0;
5004out:
5005        return err;
5006}
5007
5008static int dev_cpu_callback(struct notifier_block *nfb,
5009                            unsigned long action,
5010                            void *ocpu)
5011{
5012        struct sk_buff **list_skb;
5013        struct Qdisc **list_net;
5014        struct sk_buff *skb;
5015        unsigned int cpu, oldcpu = (unsigned long)ocpu;
5016        struct softnet_data *sd, *oldsd;
5017
5018        if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
5019                return NOTIFY_OK;
5020
5021        local_irq_disable();
5022        cpu = smp_processor_id();
5023        sd = &per_cpu(softnet_data, cpu);
5024        oldsd = &per_cpu(softnet_data, oldcpu);
5025
5026        /* Find end of our completion_queue. */
5027        list_skb = &sd->completion_queue;
5028        while (*list_skb)
5029                list_skb = &(*list_skb)->next;
5030        /* Append completion queue from offline CPU. */
5031        *list_skb = oldsd->completion_queue;
5032        oldsd->completion_queue = NULL;
5033
5034        /* Find end of our output_queue. */
5035        list_net = &sd->output_queue;
5036        while (*list_net)
5037                list_net = &(*list_net)->next_sched;
5038        /* Append output queue from offline CPU. */
5039        *list_net = oldsd->output_queue;
5040        oldsd->output_queue = NULL;
5041
5042        raise_softirq_irqoff(NET_TX_SOFTIRQ);
5043        local_irq_enable();
5044
5045        /* Process offline CPU's input_pkt_queue */
5046        while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
5047                netif_rx(skb);
5048
5049        return NOTIFY_OK;
5050}
5051
5052
5053/**
5054 *      netdev_increment_features - increment feature set by one
5055 *      @all: current feature set
5056 *      @one: new feature set
5057 *      @mask: mask feature set
5058 *
5059 *      Computes a new feature set after adding a device with feature set
5060 *      @one to the master device with current feature set @all.  Will not
5061 *      enable anything that is off in @mask. Returns the new feature set.
5062 */
5063unsigned long netdev_increment_features(unsigned long all, unsigned long one,
5064                                        unsigned long mask)
5065{
5066        /* If device needs checksumming, downgrade to it. */
5067        if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
5068                all ^= NETIF_F_NO_CSUM | (one & NETIF_F_ALL_CSUM);
5069        else if (mask & NETIF_F_ALL_CSUM) {
5070                /* If one device supports v4/v6 checksumming, set for all. */
5071                if (one & (