// SPDX-License-Identifier: GPL-2.0
#include <linux/netdevice.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <net/wext.h>
#include <net/hotdata.h>

#include "dev.h"

static void *dev_seq_from_index(struct seq_file *seq, loff_t *pos)
{
        unsigned long ifindex = *pos;
        struct net_device *dev;

        for_each_netdev_dump(seq_file_net(seq), dev, ifindex) {
                *pos = dev->ifindex;
                return dev;
        }
        return NULL;
}

static void *dev_seq_start(struct seq_file *seq, loff_t *pos)
        __acquires(RCU)
{
        rcu_read_lock();
        if (!*pos)
                return SEQ_START_TOKEN;

        return dev_seq_from_index(seq, pos);
}

static void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
        ++*pos;
        return dev_seq_from_index(seq, pos);
}

static void dev_seq_stop(struct seq_file *seq, void *v)
        __releases(RCU)
{
        rcu_read_unlock();
}

static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
{
        struct rtnl_link_stats64 temp;
        const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);

        seq_printf(seq, "%6s: %7llu %7llu %4llu %4llu %4llu %5llu %10llu %9llu "
                   "%8llu %7llu %4llu %4llu %4llu %5llu %7llu %10llu\n",
                   dev->name, stats->rx_bytes, stats->rx_packets,
                   stats->rx_errors,
                   stats->rx_dropped + stats->rx_missed_errors,
                   stats->rx_fifo_errors,
                   stats->rx_length_errors + stats->rx_over_errors +
                    stats->rx_crc_errors + stats->rx_frame_errors,
                   stats->rx_compressed, stats->multicast,
                   stats->tx_bytes, stats->tx_packets,
                   stats->tx_errors, stats->tx_dropped,
                   stats->tx_fifo_errors, stats->collisions,
                   stats->tx_carrier_errors +
                    stats->tx_aborted_errors +
                    stats->tx_window_errors +
                    stats->tx_heartbeat_errors,
                   stats->tx_compressed);
}

/*
 *      Called from the PROCfs module. This now uses the new arbitrary sized
 *      /proc/net interface to create /proc/net/dev
 */
static int dev_seq_show(struct seq_file *seq, void *v)
{
        if (v == SEQ_START_TOKEN)
                seq_puts(seq, "Inter-|   Receive                            "
                              "                    |  Transmit\n"
                              " face |bytes    packets errs drop fifo frame "
                              "compressed multicast|bytes    packets errs "
                              "drop fifo colls carrier compressed\n");
        else
                dev_seq_printf_stats(seq, v);
        return 0;
}

static u32 softnet_input_pkt_queue_len(struct softnet_data *sd)
{
        return skb_queue_len_lockless(&sd->input_pkt_queue);
}

static u32 softnet_process_queue_len(struct softnet_data *sd)
{
        return skb_queue_len_lockless(&sd->process_queue);
}

static struct softnet_data *softnet_get_online(loff_t *pos)
{
        struct softnet_data *sd = NULL;

        while (*pos < nr_cpu_ids)
                if (cpu_online(*pos)) {
                        sd = &per_cpu(softnet_data, *pos);
                        break;
                } else
                        ++*pos;
        return sd;
}

static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
{
        return softnet_get_online(pos);
}

static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
        ++*pos;
        return softnet_get_online(pos);
}

static void softnet_seq_stop(struct seq_file *seq, void *v)
{
}

static int softnet_seq_show(struct seq_file *seq, void *v)
{
        struct softnet_data *sd = v;
        u32 input_qlen = softnet_input_pkt_queue_len(sd);
        u32 process_qlen = softnet_process_queue_len(sd);
        unsigned int flow_limit_count = 0;

#ifdef CONFIG_NET_FLOW_LIMIT
        struct sd_flow_limit *fl;

        rcu_read_lock();
        fl = rcu_dereference(sd->flow_limit);
        /* Pairs with WRITE_ONCE() in skb_flow_limit() */
        if (fl)
                flow_limit_count = READ_ONCE(fl->count);
        rcu_read_unlock();
#endif

        /* the index is the CPU id owing this sd. Since offline CPUs are not
         * displayed, it would be othrwise not trivial for the user-space
         * mapping the data a specific CPU
         */
        seq_printf(seq,
                   "%08x %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x "
                   "%08x %08x\n",
                   READ_ONCE(sd->processed),
                   numa_drop_read(&sd->drop_counters),
                   READ_ONCE(sd->time_squeeze), 0,
                   0, 0, 0, 0, /* was fastroute */
                   0,   /* was cpu_collision */
                   READ_ONCE(sd->received_rps), flow_limit_count,
                   input_qlen + process_qlen, (int)seq->index,
                   input_qlen, process_qlen);
        return 0;
}

static const struct seq_operations dev_seq_ops = {
        .start = dev_seq_start,
        .next  = dev_seq_next,
        .stop  = dev_seq_stop,
        .show  = dev_seq_show,
};

static const struct seq_operations softnet_seq_ops = {
        .start = softnet_seq_start,
        .next  = softnet_seq_next,
        .stop  = softnet_seq_stop,
        .show  = softnet_seq_show,
};

struct ptype_iter_state {
        struct seq_net_private  p;
        struct net_device       *dev;
};

static void *ptype_get_idx(struct seq_file *seq, loff_t pos)
{
        struct ptype_iter_state *iter = seq->private;
        struct list_head *ptype_list = NULL;
        struct packet_type *pt = NULL;
        struct net_device *dev;
        loff_t i = 0;
        int t;

        for_each_netdev_rcu(seq_file_net(seq), dev) {
                ptype_list = &dev->ptype_all;
                list_for_each_entry_rcu(pt, ptype_list, list) {
                        if (i == pos) {
                                iter->dev = dev;
                                return pt;
                        }
                        ++i;
                }
        }

        iter->dev = NULL;

        list_for_each_entry_rcu(pt, &seq_file_net(seq)->ptype_all, list) {
                if (i == pos)
                        return pt;
                ++i;
        }

        list_for_each_entry_rcu(pt, &seq_file_net(seq)->ptype_specific, list) {
                if (i == pos)
                        return pt;
                ++i;
        }

        for (t = 0; t < PTYPE_HASH_SIZE; t++) {
                list_for_each_entry_rcu(pt, &ptype_base[t], list) {
                        if (i == pos)
                                return pt;
                        ++i;
                }
        }
        return NULL;
}

static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
        __acquires(RCU)
{
        rcu_read_lock();
        return *pos ? ptype_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
}

static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
        struct ptype_iter_state *iter = seq->private;
        struct net *net = seq_file_net(seq);
        struct net_device *dev;
        struct packet_type *pt;
        struct list_head *nxt;
        int hash;

        ++*pos;
        if (v == SEQ_START_TOKEN)
                return ptype_get_idx(seq, 0);

        pt = v;
        nxt = READ_ONCE(pt->list.next);
        dev = iter->dev;
        if (dev) {
                if (nxt != &dev->ptype_all)
                        goto found;

                for_each_netdev_continue_rcu(seq_file_net(seq), dev) {
                        nxt = READ_ONCE(dev->ptype_all.next);
                        if (nxt != &dev->ptype_all) {
                                iter->dev = dev;
                                goto found;
                        }
                }
                iter->dev = NULL;
                nxt = READ_ONCE(net->ptype_all.next);
                goto net_ptype_all;
        }

        if (pt->af_packet_net) {
net_ptype_all:
                if (nxt != &net->ptype_all && nxt != &net->ptype_specific)
                        goto found;

                if (nxt == &net->ptype_all) {
                        /* continue with ->ptype_specific if it's not empty */
                        nxt = READ_ONCE(net->ptype_specific.next);
                        if (nxt != &net->ptype_specific)
                                goto found;
                }

                hash = 0;
                nxt = READ_ONCE(ptype_base[0].next);
        } else
                hash = ntohs(pt->type) & PTYPE_HASH_MASK;

        while (nxt == &ptype_base[hash]) {
                if (++hash >= PTYPE_HASH_SIZE)
                        return NULL;
                nxt = READ_ONCE(ptype_base[hash].next);
        }
found:
        return list_entry(nxt, struct packet_type, list);
}

static void ptype_seq_stop(struct seq_file *seq, void *v)
        __releases(RCU)
{
        rcu_read_unlock();
}

static int ptype_seq_show(struct seq_file *seq, void *v)
{
        struct ptype_iter_state *iter = seq->private;
        struct packet_type *pt = v;
        struct net_device *dev;

        if (v == SEQ_START_TOKEN) {
                seq_puts(seq, "Type Device      Function\n");
                return 0;
        }
        dev = iter->dev;
        if ((!pt->af_packet_net || net_eq(pt->af_packet_net, seq_file_net(seq))) &&
                 (!dev || net_eq(dev_net(dev), seq_file_net(seq)))) {
                if (pt->type == htons(ETH_P_ALL))
                        seq_puts(seq, "ALL ");
                else
                        seq_printf(seq, "%04x", ntohs(pt->type));

                seq_printf(seq, " %-8s %ps\n",
                           dev ? dev->name : "", pt->func);
        }

        return 0;
}

static const struct seq_operations ptype_seq_ops = {
        .start = ptype_seq_start,
        .next  = ptype_seq_next,
        .stop  = ptype_seq_stop,
        .show  = ptype_seq_show,
};

static int __net_init dev_proc_net_init(struct net *net)
{
        int rc = -ENOMEM;

        if (!proc_create_net("dev", 0444, net->proc_net, &dev_seq_ops,
                        sizeof(struct seq_net_private)))
                goto out;
        if (!proc_create_seq("softnet_stat", 0444, net->proc_net,
                         &softnet_seq_ops))
                goto out_dev;
        if (!proc_create_net("ptype", 0444, net->proc_net, &ptype_seq_ops,
                        sizeof(struct ptype_iter_state)))
                goto out_softnet;

        if (wext_proc_init(net))
                goto out_ptype;
        rc = 0;
out:
        return rc;
out_ptype:
        remove_proc_entry("ptype", net->proc_net);
out_softnet:
        remove_proc_entry("softnet_stat", net->proc_net);
out_dev:
        remove_proc_entry("dev", net->proc_net);
        goto out;
}

static void __net_exit dev_proc_net_exit(struct net *net)
{
        wext_proc_exit(net);

        remove_proc_entry("ptype", net->proc_net);
        remove_proc_entry("softnet_stat", net->proc_net);
        remove_proc_entry("dev", net->proc_net);
}

static struct pernet_operations __net_initdata dev_proc_ops = {
        .init = dev_proc_net_init,
        .exit = dev_proc_net_exit,
};

static int dev_mc_seq_show(struct seq_file *seq, void *v)
{
        struct netdev_hw_addr *ha;
        struct net_device *dev = v;

        if (v == SEQ_START_TOKEN)
                return 0;

        netif_addr_lock_bh(dev);
        netdev_for_each_mc_addr(ha, dev) {
                seq_printf(seq, "%-4d %-15s %-5d %-5d %*phN\n",
                           dev->ifindex, dev->name,
                           ha->refcount, ha->global_use,
                           (int)dev->addr_len, ha->addr);
        }
        netif_addr_unlock_bh(dev);
        return 0;
}

static const struct seq_operations dev_mc_seq_ops = {
        .start = dev_seq_start,
        .next  = dev_seq_next,
        .stop  = dev_seq_stop,
        .show  = dev_mc_seq_show,
};

static int __net_init dev_mc_net_init(struct net *net)
{
        if (!proc_create_net("dev_mcast", 0, net->proc_net, &dev_mc_seq_ops,
                        sizeof(struct seq_net_private)))
                return -ENOMEM;
        return 0;
}

static void __net_exit dev_mc_net_exit(struct net *net)
{
        remove_proc_entry("dev_mcast", net->proc_net);
}

static struct pernet_operations __net_initdata dev_mc_net_ops = {
        .init = dev_mc_net_init,
        .exit = dev_mc_net_exit,
};

int __init dev_proc_init(void)
{
        int ret = register_pernet_subsys(&dev_proc_ops);
        if (!ret)
                return register_pernet_subsys(&dev_mc_net_ops);
        return ret;
}