[linux-2.6-block.git] / net / can / proc.c

// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
/*
 * proc.c - procfs support for Protocol family CAN core module
 *
 * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of Volkswagen nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * Alternatively, provided that this notice is retained in full, this
 * software may be distributed under the terms of the GNU General
 * Public License ("GPL") version 2, in which case the provisions of the
 * GPL apply INSTEAD OF those given above.
 *
 * The provided data structures and external interfaces from this code
 * are not restricted to be used by modules with a GPL compatible license.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 *
 */

#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/list.h>
#include <linux/rcupdate.h>
#include <linux/if_arp.h>
#include <linux/can/can-ml.h>
#include <linux/can/core.h>

#include "af_can.h"

/*
 * proc filenames for the PF_CAN core
 */

#define CAN_PROC_STATS       "stats"
#define CAN_PROC_RESET_STATS "reset_stats"
#define CAN_PROC_RCVLIST_ALL "rcvlist_all"
#define CAN_PROC_RCVLIST_FIL "rcvlist_fil"
#define CAN_PROC_RCVLIST_INV "rcvlist_inv"
#define CAN_PROC_RCVLIST_SFF "rcvlist_sff"
#define CAN_PROC_RCVLIST_EFF "rcvlist_eff"
#define CAN_PROC_RCVLIST_ERR "rcvlist_err"

static int user_reset;

static const char rx_list_name[][8] = {
	[RX_ERR] = "rx_err",
	[RX_ALL] = "rx_all",
	[RX_FIL] = "rx_fil",
	[RX_INV] = "rx_inv",
};

/*
 * af_can statistics stuff
 */

static void can_init_stats(struct net *net)
{
	struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
	struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
	/*
	 * This memset function is called from a timer context (when
	 * can_stattimer is active which is the default) OR in a process
	 * context (reading the proc_fs when can_stattimer is disabled).
	 */
	memset(pkg_stats, 0, sizeof(struct can_pkg_stats));
	pkg_stats->jiffies_init = jiffies;

	rcv_lists_stats->stats_reset++;

	if (user_reset) {
		user_reset = 0;
		rcv_lists_stats->user_reset++;
	}
}

static unsigned long calc_rate(unsigned long oldjif, unsigned long newjif,
			       unsigned long count)
{
	if (oldjif == newjif)
		return 0;

	/* see can_stat_update() - this should NEVER happen! */
	if (count > (ULONG_MAX / HZ)) {
		printk(KERN_ERR "can: calc_rate: count exceeded! %ld\n",
		       count);
		return 99999999;
	}

	return (count * HZ) / (newjif - oldjif);
}

void can_stat_update(struct timer_list *t)
{
	struct net *net = timer_container_of(net, t, can.stattimer);
	struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
	unsigned long j = jiffies; /* snapshot */

	long rx_frames = atomic_long_read(&pkg_stats->rx_frames);
	long tx_frames = atomic_long_read(&pkg_stats->tx_frames);
	long matches = atomic_long_read(&pkg_stats->matches);
	long rx_frames_delta = atomic_long_read(&pkg_stats->rx_frames_delta);
	long tx_frames_delta = atomic_long_read(&pkg_stats->tx_frames_delta);
	long matches_delta = atomic_long_read(&pkg_stats->matches_delta);

	/* restart counting in timer context on user request */
	if (user_reset)
		can_init_stats(net);

	/* restart counting on jiffies overflow */
	if (j < pkg_stats->jiffies_init)
		can_init_stats(net);

	/* prevent overflow in calc_rate() */
	if (rx_frames > (LONG_MAX / HZ))
		can_init_stats(net);

	/* prevent overflow in calc_rate() */
	if (tx_frames > (LONG_MAX / HZ))
		can_init_stats(net);

	/* matches overflow - very improbable */
	if (matches > (LONG_MAX / 100))
		can_init_stats(net);

	/* calc total values */
	if (rx_frames)
		pkg_stats->total_rx_match_ratio = (matches * 100) / rx_frames;

	pkg_stats->total_tx_rate = calc_rate(pkg_stats->jiffies_init, j,
					    tx_frames);
	pkg_stats->total_rx_rate = calc_rate(pkg_stats->jiffies_init, j,
					    rx_frames);

	/* calc current values */
	if (rx_frames_delta)
		pkg_stats->current_rx_match_ratio =
			(matches_delta * 100) /	rx_frames_delta;

	pkg_stats->current_tx_rate = calc_rate(0, HZ, tx_frames_delta);
	pkg_stats->current_rx_rate = calc_rate(0, HZ, rx_frames_delta);

	/* check / update maximum values */
	if (pkg_stats->max_tx_rate < pkg_stats->current_tx_rate)
		pkg_stats->max_tx_rate = pkg_stats->current_tx_rate;

	if (pkg_stats->max_rx_rate < pkg_stats->current_rx_rate)
		pkg_stats->max_rx_rate = pkg_stats->current_rx_rate;

	if (pkg_stats->max_rx_match_ratio < pkg_stats->current_rx_match_ratio)
		pkg_stats->max_rx_match_ratio = pkg_stats->current_rx_match_ratio;

	/* clear values for 'current rate' calculation */
	atomic_long_set(&pkg_stats->tx_frames_delta, 0);
	atomic_long_set(&pkg_stats->rx_frames_delta, 0);
	atomic_long_set(&pkg_stats->matches_delta, 0);

	/* restart timer (one second) */
	mod_timer(&net->can.stattimer, round_jiffies(jiffies + HZ));
}

/*
 * proc read functions
 */

static void can_print_rcvlist(struct seq_file *m, struct hlist_head *rx_list,
			      struct net_device *dev)
{
	struct receiver *r;

	hlist_for_each_entry_rcu(r, rx_list, list) {
		char *fmt = (r->can_id & CAN_EFF_FLAG)?
			"   %-5s  %08x  %08x  %pK  %pK  %8ld  %s\n" :
			"   %-5s     %03x    %08x  %pK  %pK  %8ld  %s\n";

		seq_printf(m, fmt, DNAME(dev), r->can_id, r->mask,
				r->func, r->data, r->matches, r->ident);
	}
}

static void can_print_recv_banner(struct seq_file *m)
{
	/*
	 *                  can1.  00000000  00000000  00000000
	 *                 .......          0  tp20
	 */
	if (IS_ENABLED(CONFIG_64BIT))
		seq_puts(m, "  device   can_id   can_mask      function          userdata       matches  ident\n");
	else
		seq_puts(m, "  device   can_id   can_mask  function  userdata   matches  ident\n");
}

static int can_stats_proc_show(struct seq_file *m, void *v)
{
	struct net *net = m->private;
	struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
	struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;

	seq_putc(m, '\n');
	seq_printf(m, " %8ld transmitted frames (TXF)\n",
		   atomic_long_read(&pkg_stats->tx_frames));
	seq_printf(m, " %8ld received frames (RXF)\n",
		   atomic_long_read(&pkg_stats->rx_frames));
	seq_printf(m, " %8ld matched frames (RXMF)\n",
		   atomic_long_read(&pkg_stats->matches));

	seq_putc(m, '\n');

	if (net->can.stattimer.function == can_stat_update) {
		seq_printf(m, " %8ld %% total match ratio (RXMR)\n",
				pkg_stats->total_rx_match_ratio);

		seq_printf(m, " %8ld frames/s total tx rate (TXR)\n",
				pkg_stats->total_tx_rate);
		seq_printf(m, " %8ld frames/s total rx rate (RXR)\n",
				pkg_stats->total_rx_rate);

		seq_putc(m, '\n');

		seq_printf(m, " %8ld %% current match ratio (CRXMR)\n",
				pkg_stats->current_rx_match_ratio);

		seq_printf(m, " %8ld frames/s current tx rate (CTXR)\n",
				pkg_stats->current_tx_rate);
		seq_printf(m, " %8ld frames/s current rx rate (CRXR)\n",
				pkg_stats->current_rx_rate);

		seq_putc(m, '\n');

		seq_printf(m, " %8ld %% max match ratio (MRXMR)\n",
				pkg_stats->max_rx_match_ratio);

		seq_printf(m, " %8ld frames/s max tx rate (MTXR)\n",
				pkg_stats->max_tx_rate);
		seq_printf(m, " %8ld frames/s max rx rate (MRXR)\n",
				pkg_stats->max_rx_rate);

		seq_putc(m, '\n');
	}

	seq_printf(m, " %8ld current receive list entries (CRCV)\n",
			rcv_lists_stats->rcv_entries);
	seq_printf(m, " %8ld maximum receive list entries (MRCV)\n",
			rcv_lists_stats->rcv_entries_max);

	if (rcv_lists_stats->stats_reset)
		seq_printf(m, "\n %8ld statistic resets (STR)\n",
				rcv_lists_stats->stats_reset);

	if (rcv_lists_stats->user_reset)
		seq_printf(m, " %8ld user statistic resets (USTR)\n",
				rcv_lists_stats->user_reset);

	seq_putc(m, '\n');
	return 0;
}

static int can_reset_stats_proc_show(struct seq_file *m, void *v)
{
	struct net *net = m->private;
	struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
	struct can_pkg_stats *pkg_stats = net->can.pkg_stats;

	user_reset = 1;

	if (net->can.stattimer.function == can_stat_update) {
		seq_printf(m, "Scheduled statistic reset #%ld.\n",
				rcv_lists_stats->stats_reset + 1);
	} else {
		if (pkg_stats->jiffies_init != jiffies)
			can_init_stats(net);

		seq_printf(m, "Performed statistic reset #%ld.\n",
				rcv_lists_stats->stats_reset);
	}
	return 0;
}

static inline void can_rcvlist_proc_show_one(struct seq_file *m, int idx,
					     struct net_device *dev,
					     struct can_dev_rcv_lists *dev_rcv_lists)
{
	if (!hlist_empty(&dev_rcv_lists->rx[idx])) {
		can_print_recv_banner(m);
		can_print_rcvlist(m, &dev_rcv_lists->rx[idx], dev);
	} else
		seq_printf(m, "  (%s: no entry)\n", DNAME(dev));

}

static int can_rcvlist_proc_show(struct seq_file *m, void *v)
{
	/* double cast to prevent GCC warning */
	int idx = (int)(long)pde_data(m->file->f_inode);
	struct net_device *dev;
	struct can_dev_rcv_lists *dev_rcv_lists;
	struct net *net = m->private;

	seq_printf(m, "\nreceive list '%s':\n", rx_list_name[idx]);

	rcu_read_lock();

	/* receive list for 'all' CAN devices (dev == NULL) */
	dev_rcv_lists = net->can.rx_alldev_list;
	can_rcvlist_proc_show_one(m, idx, NULL, dev_rcv_lists);

	/* receive list for registered CAN devices */
	for_each_netdev_rcu(net, dev) {
		struct can_ml_priv *can_ml = can_get_ml_priv(dev);

		if (can_ml)
			can_rcvlist_proc_show_one(m, idx, dev,
						  &can_ml->dev_rcv_lists);
	}

	rcu_read_unlock();

	seq_putc(m, '\n');
	return 0;
}

static inline void can_rcvlist_proc_show_array(struct seq_file *m,
					       struct net_device *dev,
					       struct hlist_head *rcv_array,
					       unsigned int rcv_array_sz)
{
	unsigned int i;
	int all_empty = 1;

	/* check whether at least one list is non-empty */
	for (i = 0; i < rcv_array_sz; i++)
		if (!hlist_empty(&rcv_array[i])) {
			all_empty = 0;
			break;
		}

	if (!all_empty) {
		can_print_recv_banner(m);
		for (i = 0; i < rcv_array_sz; i++) {
			if (!hlist_empty(&rcv_array[i]))
				can_print_rcvlist(m, &rcv_array[i], dev);
		}
	} else
		seq_printf(m, "  (%s: no entry)\n", DNAME(dev));
}

static int can_rcvlist_sff_proc_show(struct seq_file *m, void *v)
{
	struct net_device *dev;
	struct can_dev_rcv_lists *dev_rcv_lists;
	struct net *net = m->private;

	/* RX_SFF */
	seq_puts(m, "\nreceive list 'rx_sff':\n");

	rcu_read_lock();

	/* sff receive list for 'all' CAN devices (dev == NULL) */
	dev_rcv_lists = net->can.rx_alldev_list;
	can_rcvlist_proc_show_array(m, NULL, dev_rcv_lists->rx_sff,
				    ARRAY_SIZE(dev_rcv_lists->rx_sff));

	/* sff receive list for registered CAN devices */
	for_each_netdev_rcu(net, dev) {
		struct can_ml_priv *can_ml = can_get_ml_priv(dev);

		if (can_ml) {
			dev_rcv_lists = &can_ml->dev_rcv_lists;
			can_rcvlist_proc_show_array(m, dev, dev_rcv_lists->rx_sff,
						    ARRAY_SIZE(dev_rcv_lists->rx_sff));
		}
	}

	rcu_read_unlock();

	seq_putc(m, '\n');
	return 0;
}

static int can_rcvlist_eff_proc_show(struct seq_file *m, void *v)
{
	struct net_device *dev;
	struct can_dev_rcv_lists *dev_rcv_lists;
	struct net *net = m->private;

	/* RX_EFF */
	seq_puts(m, "\nreceive list 'rx_eff':\n");

	rcu_read_lock();

	/* eff receive list for 'all' CAN devices (dev == NULL) */
	dev_rcv_lists = net->can.rx_alldev_list;
	can_rcvlist_proc_show_array(m, NULL, dev_rcv_lists->rx_eff,
				    ARRAY_SIZE(dev_rcv_lists->rx_eff));

	/* eff receive list for registered CAN devices */
	for_each_netdev_rcu(net, dev) {
		struct can_ml_priv *can_ml = can_get_ml_priv(dev);

		if (can_ml) {
			dev_rcv_lists = &can_ml->dev_rcv_lists;
			can_rcvlist_proc_show_array(m, dev, dev_rcv_lists->rx_eff,
						    ARRAY_SIZE(dev_rcv_lists->rx_eff));
		}
	}

	rcu_read_unlock();

	seq_putc(m, '\n');
	return 0;
}

/*
 * can_init_proc - create main CAN proc directory and procfs entries
 */
void can_init_proc(struct net *net)
{
	/* create /proc/net/can directory */
	net->can.proc_dir = proc_net_mkdir(net, "can", net->proc_net);

	if (!net->can.proc_dir) {
		printk(KERN_INFO "can: failed to create /proc/net/can . "
			   "CONFIG_PROC_FS missing?\n");
		return;
	}

	/* own procfs entries from the AF_CAN core */
	net->can.pde_stats = proc_create_net_single(CAN_PROC_STATS, 0644,
			net->can.proc_dir, can_stats_proc_show, NULL);
	net->can.pde_reset_stats = proc_create_net_single(CAN_PROC_RESET_STATS,
			0644, net->can.proc_dir, can_reset_stats_proc_show,
			NULL);
	net->can.pde_rcvlist_err = proc_create_net_single(CAN_PROC_RCVLIST_ERR,
			0644, net->can.proc_dir, can_rcvlist_proc_show,
			(void *)RX_ERR);
	net->can.pde_rcvlist_all = proc_create_net_single(CAN_PROC_RCVLIST_ALL,
			0644, net->can.proc_dir, can_rcvlist_proc_show,
			(void *)RX_ALL);
	net->can.pde_rcvlist_fil = proc_create_net_single(CAN_PROC_RCVLIST_FIL,
			0644, net->can.proc_dir, can_rcvlist_proc_show,
			(void *)RX_FIL);
	net->can.pde_rcvlist_inv = proc_create_net_single(CAN_PROC_RCVLIST_INV,
			0644, net->can.proc_dir, can_rcvlist_proc_show,
			(void *)RX_INV);
	net->can.pde_rcvlist_eff = proc_create_net_single(CAN_PROC_RCVLIST_EFF,
			0644, net->can.proc_dir, can_rcvlist_eff_proc_show, NULL);
	net->can.pde_rcvlist_sff = proc_create_net_single(CAN_PROC_RCVLIST_SFF,
			0644, net->can.proc_dir, can_rcvlist_sff_proc_show, NULL);
}

/*
 * can_remove_proc - remove procfs entries and main CAN proc directory
 */
void can_remove_proc(struct net *net)
{
	if (!net->can.proc_dir)
		return;

	if (net->can.pde_stats)
		remove_proc_entry(CAN_PROC_STATS, net->can.proc_dir);

	if (net->can.pde_reset_stats)
		remove_proc_entry(CAN_PROC_RESET_STATS, net->can.proc_dir);

	if (net->can.pde_rcvlist_err)
		remove_proc_entry(CAN_PROC_RCVLIST_ERR, net->can.proc_dir);

	if (net->can.pde_rcvlist_all)
		remove_proc_entry(CAN_PROC_RCVLIST_ALL, net->can.proc_dir);

	if (net->can.pde_rcvlist_fil)
		remove_proc_entry(CAN_PROC_RCVLIST_FIL, net->can.proc_dir);

	if (net->can.pde_rcvlist_inv)
		remove_proc_entry(CAN_PROC_RCVLIST_INV, net->can.proc_dir);

	if (net->can.pde_rcvlist_eff)
		remove_proc_entry(CAN_PROC_RCVLIST_EFF, net->can.proc_dir);

	if (net->can.pde_rcvlist_sff)
		remove_proc_entry(CAN_PROC_RCVLIST_SFF, net->can.proc_dir);

	remove_proc_entry("can", net->proc_net);
}
Commit	Line	Data
	1	// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
	2	/*
	3	* proc.c - procfs support for Protocol family CAN core module
	4	*
	5	* Copyright (c) 2002-2007 Volkswagen Group Electronic Research
	6	* All rights reserved.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions
	10	* are met:
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* 2. Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in the
	15	* documentation and/or other materials provided with the distribution.
	16	* 3. Neither the name of Volkswagen nor the names of its contributors
	17	* may be used to endorse or promote products derived from this software
	18	* without specific prior written permission.
	19	*
	20	* Alternatively, provided that this notice is retained in full, this
	21	* software may be distributed under the terms of the GNU General
	22	* Public License ("GPL") version 2, in which case the provisions of the
	23	* GPL apply INSTEAD OF those given above.
	24	*
	25	* The provided data structures and external interfaces from this code
	26	* are not restricted to be used by modules with a GPL compatible license.
	27	*
	28	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	29	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	30	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	31	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	32	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	33	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	34	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	35	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	36	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	37	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	38	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
	39	* DAMAGE.
	40	*
	41	*/
	42
	43	#include <linux/module.h>
	44	#include <linux/proc_fs.h>
	45	#include <linux/list.h>
	46	#include <linux/rcupdate.h>
	47	#include <linux/if_arp.h>
	48	#include <linux/can/can-ml.h>
	49	#include <linux/can/core.h>
	50
	51	#include "af_can.h"
	52
	53	/*
	54	* proc filenames for the PF_CAN core
	55	*/
	56
	57	#define CAN_PROC_STATS "stats"
	58	#define CAN_PROC_RESET_STATS "reset_stats"
	59	#define CAN_PROC_RCVLIST_ALL "rcvlist_all"
	60	#define CAN_PROC_RCVLIST_FIL "rcvlist_fil"
	61	#define CAN_PROC_RCVLIST_INV "rcvlist_inv"
	62	#define CAN_PROC_RCVLIST_SFF "rcvlist_sff"
	63	#define CAN_PROC_RCVLIST_EFF "rcvlist_eff"
	64	#define CAN_PROC_RCVLIST_ERR "rcvlist_err"
	65
	66	static int user_reset;
	67
	68	static const char rx_list_name[][8] = {
	69	[RX_ERR] = "rx_err",
	70	[RX_ALL] = "rx_all",
	71	[RX_FIL] = "rx_fil",
	72	[RX_INV] = "rx_inv",
	73	};
	74
	75	/*
	76	* af_can statistics stuff
	77	*/
	78
	79	static void can_init_stats(struct net *net)
	80	{
	81	struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
	82	struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
	83	/*
	84	* This memset function is called from a timer context (when
	85	* can_stattimer is active which is the default) OR in a process
	86	* context (reading the proc_fs when can_stattimer is disabled).
	87	*/
	88	memset(pkg_stats, 0, sizeof(struct can_pkg_stats));
	89	pkg_stats->jiffies_init = jiffies;
	90
	91	rcv_lists_stats->stats_reset++;
	92
	93	if (user_reset) {
	94	user_reset = 0;
	95	rcv_lists_stats->user_reset++;
	96	}
	97	}
	98
	99	static unsigned long calc_rate(unsigned long oldjif, unsigned long newjif,
	100	unsigned long count)
	101	{
	102	if (oldjif == newjif)
	103	return 0;
	104
	105	/* see can_stat_update() - this should NEVER happen! */
	106	if (count > (ULONG_MAX / HZ)) {
	107	printk(KERN_ERR "can: calc_rate: count exceeded! %ld\n",
	108	count);
	109	return 99999999;
	110	}
	111
	112	return (count * HZ) / (newjif - oldjif);
	113	}
	114
	115	void can_stat_update(struct timer_list *t)
	116	{
	117	struct net *net = timer_container_of(net, t, can.stattimer);
	118	struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
	119	unsigned long j = jiffies; /* snapshot */
	120
	121	long rx_frames = atomic_long_read(&pkg_stats->rx_frames);
	122	long tx_frames = atomic_long_read(&pkg_stats->tx_frames);
	123	long matches = atomic_long_read(&pkg_stats->matches);
	124	long rx_frames_delta = atomic_long_read(&pkg_stats->rx_frames_delta);
	125	long tx_frames_delta = atomic_long_read(&pkg_stats->tx_frames_delta);
	126	long matches_delta = atomic_long_read(&pkg_stats->matches_delta);
	127
	128	/* restart counting in timer context on user request */
	129	if (user_reset)
	130	can_init_stats(net);
	131
	132	/* restart counting on jiffies overflow */
	133	if (j < pkg_stats->jiffies_init)
	134	can_init_stats(net);
	135
	136	/* prevent overflow in calc_rate() */
	137	if (rx_frames > (LONG_MAX / HZ))
	138	can_init_stats(net);
	139
	140	/* prevent overflow in calc_rate() */
	141	if (tx_frames > (LONG_MAX / HZ))
	142	can_init_stats(net);
	143
	144	/* matches overflow - very improbable */
	145	if (matches > (LONG_MAX / 100))
	146	can_init_stats(net);
	147
	148	/* calc total values */
	149	if (rx_frames)
	150	pkg_stats->total_rx_match_ratio = (matches * 100) / rx_frames;
	151
	152	pkg_stats->total_tx_rate = calc_rate(pkg_stats->jiffies_init, j,
	153	tx_frames);
	154	pkg_stats->total_rx_rate = calc_rate(pkg_stats->jiffies_init, j,
	155	rx_frames);
	156
	157	/* calc current values */
	158	if (rx_frames_delta)
	159	pkg_stats->current_rx_match_ratio =
	160	(matches_delta * 100) / rx_frames_delta;
	161
	162	pkg_stats->current_tx_rate = calc_rate(0, HZ, tx_frames_delta);
	163	pkg_stats->current_rx_rate = calc_rate(0, HZ, rx_frames_delta);
	164
	165	/* check / update maximum values */
	166	if (pkg_stats->max_tx_rate < pkg_stats->current_tx_rate)
	167	pkg_stats->max_tx_rate = pkg_stats->current_tx_rate;
	168
	169	if (pkg_stats->max_rx_rate < pkg_stats->current_rx_rate)
	170	pkg_stats->max_rx_rate = pkg_stats->current_rx_rate;
	171
	172	if (pkg_stats->max_rx_match_ratio < pkg_stats->current_rx_match_ratio)
	173	pkg_stats->max_rx_match_ratio = pkg_stats->current_rx_match_ratio;
	174
	175	/* clear values for 'current rate' calculation */
	176	atomic_long_set(&pkg_stats->tx_frames_delta, 0);
	177	atomic_long_set(&pkg_stats->rx_frames_delta, 0);
	178	atomic_long_set(&pkg_stats->matches_delta, 0);
	179
	180	/* restart timer (one second) */
	181	mod_timer(&net->can.stattimer, round_jiffies(jiffies + HZ));
	182	}
	183
	184	/*
	185	* proc read functions
	186	*/
	187
	188	static void can_print_rcvlist(struct seq_file m, struct hlist_head rx_list,
	189	struct net_device *dev)
	190	{
	191	struct receiver *r;
	192
	193	hlist_for_each_entry_rcu(r, rx_list, list) {
	194	char *fmt = (r->can_id & CAN_EFF_FLAG)?
	195	" %-5s %08x %08x %pK %pK %8ld %s\n" :
	196	" %-5s %03x %08x %pK %pK %8ld %s\n";
	197
	198	seq_printf(m, fmt, DNAME(dev), r->can_id, r->mask,
	199	r->func, r->data, r->matches, r->ident);
	200	}
	201	}
	202
	203	static void can_print_recv_banner(struct seq_file *m)
	204	{
	205	/*
	206	* can1. 00000000 00000000 00000000
	207	* ....... 0 tp20
	208	*/
	209	if (IS_ENABLED(CONFIG_64BIT))
	210	seq_puts(m, " device can_id can_mask function userdata matches ident\n");
	211	else
	212	seq_puts(m, " device can_id can_mask function userdata matches ident\n");
	213	}
	214
	215	static int can_stats_proc_show(struct seq_file m, void v)
	216	{
	217	struct net *net = m->private;
	218	struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
	219	struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
	220
	221	seq_putc(m, '\n');
	222	seq_printf(m, " %8ld transmitted frames (TXF)\n",
	223	atomic_long_read(&pkg_stats->tx_frames));
	224	seq_printf(m, " %8ld received frames (RXF)\n",
	225	atomic_long_read(&pkg_stats->rx_frames));
	226	seq_printf(m, " %8ld matched frames (RXMF)\n",
	227	atomic_long_read(&pkg_stats->matches));
	228
	229	seq_putc(m, '\n');
	230
	231	if (net->can.stattimer.function == can_stat_update) {
	232	seq_printf(m, " %8ld %% total match ratio (RXMR)\n",
	233	pkg_stats->total_rx_match_ratio);
	234
	235	seq_printf(m, " %8ld frames/s total tx rate (TXR)\n",
	236	pkg_stats->total_tx_rate);
	237	seq_printf(m, " %8ld frames/s total rx rate (RXR)\n",
	238	pkg_stats->total_rx_rate);
	239
	240	seq_putc(m, '\n');
	241
	242	seq_printf(m, " %8ld %% current match ratio (CRXMR)\n",
	243	pkg_stats->current_rx_match_ratio);
	244
	245	seq_printf(m, " %8ld frames/s current tx rate (CTXR)\n",
	246	pkg_stats->current_tx_rate);
	247	seq_printf(m, " %8ld frames/s current rx rate (CRXR)\n",
	248	pkg_stats->current_rx_rate);
	249
	250	seq_putc(m, '\n');
	251
	252	seq_printf(m, " %8ld %% max match ratio (MRXMR)\n",
	253	pkg_stats->max_rx_match_ratio);
	254
	255	seq_printf(m, " %8ld frames/s max tx rate (MTXR)\n",
	256	pkg_stats->max_tx_rate);
	257	seq_printf(m, " %8ld frames/s max rx rate (MRXR)\n",
	258	pkg_stats->max_rx_rate);
	259
	260	seq_putc(m, '\n');
	261	}
	262
	263	seq_printf(m, " %8ld current receive list entries (CRCV)\n",
	264	rcv_lists_stats->rcv_entries);
	265	seq_printf(m, " %8ld maximum receive list entries (MRCV)\n",
	266	rcv_lists_stats->rcv_entries_max);
	267
	268	if (rcv_lists_stats->stats_reset)
	269	seq_printf(m, "\n %8ld statistic resets (STR)\n",
	270	rcv_lists_stats->stats_reset);
	271
	272	if (rcv_lists_stats->user_reset)
	273	seq_printf(m, " %8ld user statistic resets (USTR)\n",
	274	rcv_lists_stats->user_reset);
	275
	276	seq_putc(m, '\n');
	277	return 0;
	278	}
	279
	280	static int can_reset_stats_proc_show(struct seq_file m, void v)
	281	{
	282	struct net *net = m->private;
	283	struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
	284	struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
	285
	286	user_reset = 1;
	287
	288	if (net->can.stattimer.function == can_stat_update) {
	289	seq_printf(m, "Scheduled statistic reset #%ld.\n",
	290	rcv_lists_stats->stats_reset + 1);
	291	} else {
	292	if (pkg_stats->jiffies_init != jiffies)
	293	can_init_stats(net);
	294
	295	seq_printf(m, "Performed statistic reset #%ld.\n",
	296	rcv_lists_stats->stats_reset);
	297	}
	298	return 0;
	299	}
	300
	301	static inline void can_rcvlist_proc_show_one(struct seq_file *m, int idx,
	302	struct net_device *dev,
	303	struct can_dev_rcv_lists *dev_rcv_lists)
	304	{
	305	if (!hlist_empty(&dev_rcv_lists->rx[idx])) {
	306	can_print_recv_banner(m);
	307	can_print_rcvlist(m, &dev_rcv_lists->rx[idx], dev);
	308	} else
	309	seq_printf(m, " (%s: no entry)\n", DNAME(dev));
	310
	311	}
	312
	313	static int can_rcvlist_proc_show(struct seq_file m, void v)
	314	{
	315	/* double cast to prevent GCC warning */
	316	int idx = (int)(long)pde_data(m->file->f_inode);
	317	struct net_device *dev;
	318	struct can_dev_rcv_lists *dev_rcv_lists;
	319	struct net *net = m->private;
	320
	321	seq_printf(m, "\nreceive list '%s':\n", rx_list_name[idx]);
	322
	323	rcu_read_lock();
	324
	325	/* receive list for 'all' CAN devices (dev == NULL) */
	326	dev_rcv_lists = net->can.rx_alldev_list;
	327	can_rcvlist_proc_show_one(m, idx, NULL, dev_rcv_lists);
	328
	329	/* receive list for registered CAN devices */
	330	for_each_netdev_rcu(net, dev) {
	331	struct can_ml_priv *can_ml = can_get_ml_priv(dev);
	332
	333	if (can_ml)
	334	can_rcvlist_proc_show_one(m, idx, dev,
	335	&can_ml->dev_rcv_lists);
	336	}
	337
	338	rcu_read_unlock();
	339
	340	seq_putc(m, '\n');
	341	return 0;
	342	}
	343
	344	static inline void can_rcvlist_proc_show_array(struct seq_file *m,
	345	struct net_device *dev,
	346	struct hlist_head *rcv_array,
	347	unsigned int rcv_array_sz)
	348	{
	349	unsigned int i;
	350	int all_empty = 1;
	351
	352	/* check whether at least one list is non-empty */
	353	for (i = 0; i < rcv_array_sz; i++)
	354	if (!hlist_empty(&rcv_array[i])) {
	355	all_empty = 0;
	356	break;
	357	}
	358
	359	if (!all_empty) {
	360	can_print_recv_banner(m);
	361	for (i = 0; i < rcv_array_sz; i++) {
	362	if (!hlist_empty(&rcv_array[i]))
	363	can_print_rcvlist(m, &rcv_array[i], dev);
	364	}
	365	} else
	366	seq_printf(m, " (%s: no entry)\n", DNAME(dev));
	367	}
	368
	369	static int can_rcvlist_sff_proc_show(struct seq_file m, void v)
	370	{
	371	struct net_device *dev;
	372	struct can_dev_rcv_lists *dev_rcv_lists;
	373	struct net *net = m->private;
	374
	375	/* RX_SFF */
	376	seq_puts(m, "\nreceive list 'rx_sff':\n");
	377
	378	rcu_read_lock();
	379
	380	/* sff receive list for 'all' CAN devices (dev == NULL) */
	381	dev_rcv_lists = net->can.rx_alldev_list;
	382	can_rcvlist_proc_show_array(m, NULL, dev_rcv_lists->rx_sff,
	383	ARRAY_SIZE(dev_rcv_lists->rx_sff));
	384
	385	/* sff receive list for registered CAN devices */
	386	for_each_netdev_rcu(net, dev) {
	387	struct can_ml_priv *can_ml = can_get_ml_priv(dev);
	388
	389	if (can_ml) {
	390	dev_rcv_lists = &can_ml->dev_rcv_lists;
	391	can_rcvlist_proc_show_array(m, dev, dev_rcv_lists->rx_sff,
	392	ARRAY_SIZE(dev_rcv_lists->rx_sff));
	393	}
	394	}
	395
	396	rcu_read_unlock();
	397
	398	seq_putc(m, '\n');
	399	return 0;
	400	}
	401
	402	static int can_rcvlist_eff_proc_show(struct seq_file m, void v)
	403	{
	404	struct net_device *dev;
	405	struct can_dev_rcv_lists *dev_rcv_lists;
	406	struct net *net = m->private;
	407
	408	/* RX_EFF */
	409	seq_puts(m, "\nreceive list 'rx_eff':\n");
	410
	411	rcu_read_lock();
	412
	413	/* eff receive list for 'all' CAN devices (dev == NULL) */
	414	dev_rcv_lists = net->can.rx_alldev_list;
	415	can_rcvlist_proc_show_array(m, NULL, dev_rcv_lists->rx_eff,
	416	ARRAY_SIZE(dev_rcv_lists->rx_eff));
	417
	418	/* eff receive list for registered CAN devices */
	419	for_each_netdev_rcu(net, dev) {
	420	struct can_ml_priv *can_ml = can_get_ml_priv(dev);
	421
	422	if (can_ml) {
	423	dev_rcv_lists = &can_ml->dev_rcv_lists;
	424	can_rcvlist_proc_show_array(m, dev, dev_rcv_lists->rx_eff,
	425	ARRAY_SIZE(dev_rcv_lists->rx_eff));
	426	}
	427	}
	428
	429	rcu_read_unlock();
	430
	431	seq_putc(m, '\n');
	432	return 0;
	433	}
	434
	435	/*
	436	* can_init_proc - create main CAN proc directory and procfs entries
	437	*/
	438	void can_init_proc(struct net *net)
	439	{
	440	/* create /proc/net/can directory */
	441	net->can.proc_dir = proc_net_mkdir(net, "can", net->proc_net);
	442
	443	if (!net->can.proc_dir) {
	444	printk(KERN_INFO "can: failed to create /proc/net/can . "
	445	"CONFIG_PROC_FS missing?\n");
	446	return;
	447	}
	448
	449	/* own procfs entries from the AF_CAN core */
	450	net->can.pde_stats = proc_create_net_single(CAN_PROC_STATS, 0644,
	451	net->can.proc_dir, can_stats_proc_show, NULL);
	452	net->can.pde_reset_stats = proc_create_net_single(CAN_PROC_RESET_STATS,
	453	0644, net->can.proc_dir, can_reset_stats_proc_show,
	454	NULL);
	455	net->can.pde_rcvlist_err = proc_create_net_single(CAN_PROC_RCVLIST_ERR,
	456	0644, net->can.proc_dir, can_rcvlist_proc_show,
	457	(void *)RX_ERR);
	458	net->can.pde_rcvlist_all = proc_create_net_single(CAN_PROC_RCVLIST_ALL,
	459	0644, net->can.proc_dir, can_rcvlist_proc_show,
	460	(void *)RX_ALL);
	461	net->can.pde_rcvlist_fil = proc_create_net_single(CAN_PROC_RCVLIST_FIL,
	462	0644, net->can.proc_dir, can_rcvlist_proc_show,
	463	(void *)RX_FIL);
	464	net->can.pde_rcvlist_inv = proc_create_net_single(CAN_PROC_RCVLIST_INV,
	465	0644, net->can.proc_dir, can_rcvlist_proc_show,
	466	(void *)RX_INV);
	467	net->can.pde_rcvlist_eff = proc_create_net_single(CAN_PROC_RCVLIST_EFF,
	468	0644, net->can.proc_dir, can_rcvlist_eff_proc_show, NULL);
	469	net->can.pde_rcvlist_sff = proc_create_net_single(CAN_PROC_RCVLIST_SFF,
	470	0644, net->can.proc_dir, can_rcvlist_sff_proc_show, NULL);
	471	}
	472
	473	/*
	474	* can_remove_proc - remove procfs entries and main CAN proc directory
	475	*/
	476	void can_remove_proc(struct net *net)
	477	{
	478	if (!net->can.proc_dir)
	479	return;
	480
	481	if (net->can.pde_stats)
	482	remove_proc_entry(CAN_PROC_STATS, net->can.proc_dir);
	483
	484	if (net->can.pde_reset_stats)
	485	remove_proc_entry(CAN_PROC_RESET_STATS, net->can.proc_dir);
	486
	487	if (net->can.pde_rcvlist_err)
	488	remove_proc_entry(CAN_PROC_RCVLIST_ERR, net->can.proc_dir);
	489
	490	if (net->can.pde_rcvlist_all)
	491	remove_proc_entry(CAN_PROC_RCVLIST_ALL, net->can.proc_dir);
	492
	493	if (net->can.pde_rcvlist_fil)
	494	remove_proc_entry(CAN_PROC_RCVLIST_FIL, net->can.proc_dir);
	495
	496	if (net->can.pde_rcvlist_inv)
	497	remove_proc_entry(CAN_PROC_RCVLIST_INV, net->can.proc_dir);
	498
	499	if (net->can.pde_rcvlist_eff)
	500	remove_proc_entry(CAN_PROC_RCVLIST_EFF, net->can.proc_dir);
	501
	502	if (net->can.pde_rcvlist_sff)
	503	remove_proc_entry(CAN_PROC_RCVLIST_SFF, net->can.proc_dir);
	504
	505	remove_proc_entry("can", net->proc_net);
	506	}