In order for the network device ops get_stats call to be immutable, the handling
of the default internal network device stats block has to be changed. Add a new
helper function which replaces the old use of internal_get_stats.
Note: change return code to make it clear that the caller should not
go changing the returned statistics.
Signed-off-by: Stephen Hemminger <shemminger@vyatta.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
        int i;
        struct appldata_net_sum_data *net_data;
        struct net_device *dev;
-       struct net_device_stats *stats;
        unsigned long rx_packets, tx_packets, rx_bytes, tx_bytes, rx_errors,
                        tx_errors, rx_dropped, tx_dropped, collisions;
 
        collisions = 0;
        read_lock(&dev_base_lock);
        for_each_netdev(&init_net, dev) {
-               stats = dev->get_stats(dev);
+               const struct net_device_stats *stats = dev_get_stats(dev);
+
                rx_packets += stats->rx_packets;
                tx_packets += stats->tx_packets;
                rx_bytes   += stats->rx_bytes;
 
 static struct net_device_stats *bond_get_stats(struct net_device *bond_dev)
 {
        struct bonding *bond = netdev_priv(bond_dev);
-       struct net_device_stats *stats = &(bond->stats), *sstats;
+       struct net_device_stats *stats = &bond->stats;
        struct net_device_stats local_stats;
        struct slave *slave;
        int i;
        read_lock_bh(&bond->lock);
 
        bond_for_each_slave(bond, slave, i) {
-               sstats = slave->dev->get_stats(slave->dev);
+               const struct net_device_stats *sstats = dev_get_stats(slave->dev);
+
                local_stats.rx_packets += sstats->rx_packets;
                local_stats.rx_bytes += sstats->rx_bytes;
                local_stats.rx_errors += sstats->rx_errors;
 
        EFX_BUG_ON_PARANOID(stats->n_stats != EFX_ETHTOOL_NUM_STATS);
 
        /* Update MAC and NIC statistics */
-       net_dev->get_stats(net_dev);
+       dev_get_stats(net_dev);
 
        /* Fill detailed statistics buffer */
        for (i = 0; i < EFX_ETHTOOL_NUM_STATS; i++) {
 
        read_lock(&dev_base_lock);
        rcu_read_lock();
        for_each_netdev(&init_net, dev) {
-           struct net_device_stats *stats;
+           const struct net_device_stats *stats;
            struct in_device *in_dev = __in_dev_get_rcu(dev);
            if (!in_dev || !in_dev->ifa_list)
                continue;
            if (ipv4_is_loopback(in_dev->ifa_list->ifa_local))
                continue;
-           stats = dev->get_stats(dev);
+           stats = dev_get_stats(dev);
            rx_total += stats->rx_packets;
            tx_total += stats->tx_packets;
        }
 
                                                            unsigned short vid);
 #ifdef CONFIG_NET_POLL_CONTROLLER
                void                    (*poll_controller)(struct net_device *dev);
-#endif
 #endif
        };
+#endif
 };
 #define to_net_dev(d) container_of(d, struct net_device, dev)
 
 /* Load a device via the kmod */
 extern void            dev_load(struct net *net, const char *name);
 extern void            dev_mcast_init(void);
+extern const struct net_device_stats *dev_get_stats(struct net_device *dev);
+
 extern int             netdev_max_backlog;
 extern int             weight_p;
 extern int             netdev_set_master(struct net_device *dev, struct net_device *master);
 
 
 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
 {
-       struct net_device_stats *stats = dev->get_stats(dev);
+       const struct net_device_stats *stats = dev_get_stats(dev);
 
        seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
                   "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
        }
 }
 
-static struct net_device_stats *internal_stats(struct net_device *dev)
-{
-       return &dev->stats;
+/**
+ *     dev_get_stats   - get network device statistics
+ *     @dev: device to get statistics from
+ *
+ *     Get network statistics from device. The device driver may provide
+ *     its own method by setting dev->netdev_ops->get_stats; otherwise
+ *     the internal statistics structure is used.
+ */
+const struct net_device_stats *dev_get_stats(struct net_device *dev)
+ {
+       const struct net_device_ops *ops = dev->netdev_ops;
+
+       if (ops->ndo_get_stats)
+               return ops->ndo_get_stats(dev);
+       else
+               return &dev->stats;
 }
+EXPORT_SYMBOL(dev_get_stats);
 
 static void netdev_init_one_queue(struct net_device *dev,
                                  struct netdev_queue *queue,
 
        netdev_init_queues(dev);
 
-       dev->get_stats = internal_stats;
        netpoll_netdev_init(dev);
        setup(dev);
        strcpy(dev->name, name);
 
                            unsigned long offset)
 {
        struct net_device *dev = to_net_dev(d);
-       struct net_device_stats *stats;
        ssize_t ret = -EINVAL;
 
        WARN_ON(offset > sizeof(struct net_device_stats) ||
 
        read_lock(&dev_base_lock);
        if (dev_isalive(dev)) {
-               stats = dev->get_stats(dev);
+               const struct net_device_stats *stats = dev_get_stats(dev);
                ret = sprintf(buf, fmt_ulong,
                              *(unsigned long *)(((u8 *) stats) + offset));
        }
 
 }
 
 static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
-                                struct net_device_stats *b)
+                                const struct net_device_stats *b)
 {
        a->rx_packets = b->rx_packets;
        a->tx_packets = b->tx_packets;
        struct netdev_queue *txq;
        struct ifinfomsg *ifm;
        struct nlmsghdr *nlh;
-       struct net_device_stats *stats;
+       const struct net_device_stats *stats;
        struct nlattr *attr;
 
        nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
        if (attr == NULL)
                goto nla_put_failure;
 
-       stats = dev->get_stats(dev);
+       stats = dev_get_stats(dev);
        copy_rtnl_link_stats(nla_data(attr), stats);
 
        if (dev->rtnl_link_ops) {