[linux-block.git] / net / 6lowpan / debugfs.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 *
 * Authors:
 * (C) 2015 Pengutronix, Alexander Aring <aar@pengutronix.de>
 * Copyright (c)  2015 Nordic Semiconductor. All Rights Reserved.
 */

#include <net/6lowpan.h>

#include "6lowpan_i.h"

#define LOWPAN_DEBUGFS_CTX_PFX_NUM_ARGS	8

static struct dentry *lowpan_debugfs;

static int lowpan_ctx_flag_active_set(void *data, u64 val)
{
	struct lowpan_iphc_ctx *ctx = data;

	if (val != 0 && val != 1)
		return -EINVAL;

	if (val)
		set_bit(LOWPAN_IPHC_CTX_FLAG_ACTIVE, &ctx->flags);
	else
		clear_bit(LOWPAN_IPHC_CTX_FLAG_ACTIVE, &ctx->flags);

	return 0;
}

static int lowpan_ctx_flag_active_get(void *data, u64 *val)
{
	*val = lowpan_iphc_ctx_is_active(data);
	return 0;
}

DEFINE_DEBUGFS_ATTRIBUTE(lowpan_ctx_flag_active_fops,
			 lowpan_ctx_flag_active_get,
			 lowpan_ctx_flag_active_set, "%llu\n");

static int lowpan_ctx_flag_c_set(void *data, u64 val)
{
	struct lowpan_iphc_ctx *ctx = data;

	if (val != 0 && val != 1)
		return -EINVAL;

	if (val)
		set_bit(LOWPAN_IPHC_CTX_FLAG_COMPRESSION, &ctx->flags);
	else
		clear_bit(LOWPAN_IPHC_CTX_FLAG_COMPRESSION, &ctx->flags);

	return 0;
}

static int lowpan_ctx_flag_c_get(void *data, u64 *val)
{
	*val = lowpan_iphc_ctx_is_compression(data);
	return 0;
}

DEFINE_DEBUGFS_ATTRIBUTE(lowpan_ctx_flag_c_fops, lowpan_ctx_flag_c_get,
			 lowpan_ctx_flag_c_set, "%llu\n");

static int lowpan_ctx_plen_set(void *data, u64 val)
{
	struct lowpan_iphc_ctx *ctx = data;
	struct lowpan_iphc_ctx_table *t =
		container_of(ctx, struct lowpan_iphc_ctx_table, table[ctx->id]);

	if (val > 128)
		return -EINVAL;

	spin_lock_bh(&t->lock);
	ctx->plen = val;
	spin_unlock_bh(&t->lock);

	return 0;
}

static int lowpan_ctx_plen_get(void *data, u64 *val)
{
	struct lowpan_iphc_ctx *ctx = data;
	struct lowpan_iphc_ctx_table *t =
		container_of(ctx, struct lowpan_iphc_ctx_table, table[ctx->id]);

	spin_lock_bh(&t->lock);
	*val = ctx->plen;
	spin_unlock_bh(&t->lock);
	return 0;
}

DEFINE_DEBUGFS_ATTRIBUTE(lowpan_ctx_plen_fops, lowpan_ctx_plen_get,
			 lowpan_ctx_plen_set, "%llu\n");

static int lowpan_ctx_pfx_show(struct seq_file *file, void *offset)
{
	struct lowpan_iphc_ctx *ctx = file->private;
	struct lowpan_iphc_ctx_table *t =
		container_of(ctx, struct lowpan_iphc_ctx_table, table[ctx->id]);

	spin_lock_bh(&t->lock);
	seq_printf(file, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
		   be16_to_cpu(ctx->pfx.s6_addr16[0]),
		   be16_to_cpu(ctx->pfx.s6_addr16[1]),
		   be16_to_cpu(ctx->pfx.s6_addr16[2]),
		   be16_to_cpu(ctx->pfx.s6_addr16[3]),
		   be16_to_cpu(ctx->pfx.s6_addr16[4]),
		   be16_to_cpu(ctx->pfx.s6_addr16[5]),
		   be16_to_cpu(ctx->pfx.s6_addr16[6]),
		   be16_to_cpu(ctx->pfx.s6_addr16[7]));
	spin_unlock_bh(&t->lock);

	return 0;
}

static int lowpan_ctx_pfx_open(struct inode *inode, struct file *file)
{
	return single_open(file, lowpan_ctx_pfx_show, inode->i_private);
}

static ssize_t lowpan_ctx_pfx_write(struct file *fp,
				    const char __user *user_buf, size_t count,
				    loff_t *ppos)
{
	char buf[128] = {};
	struct seq_file *file = fp->private_data;
	struct lowpan_iphc_ctx *ctx = file->private;
	struct lowpan_iphc_ctx_table *t =
		container_of(ctx, struct lowpan_iphc_ctx_table, table[ctx->id]);
	int status = count, n, i;
	unsigned int addr[8];

	if (copy_from_user(&buf, user_buf, min_t(size_t, sizeof(buf) - 1,
						 count))) {
		status = -EFAULT;
		goto out;
	}

	n = sscanf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
		   &addr[0], &addr[1], &addr[2], &addr[3], &addr[4],
		   &addr[5], &addr[6], &addr[7]);
	if (n != LOWPAN_DEBUGFS_CTX_PFX_NUM_ARGS) {
		status = -EINVAL;
		goto out;
	}

	spin_lock_bh(&t->lock);
	for (i = 0; i < 8; i++)
		ctx->pfx.s6_addr16[i] = cpu_to_be16(addr[i] & 0xffff);
	spin_unlock_bh(&t->lock);

out:
	return status;
}

static const struct file_operations lowpan_ctx_pfx_fops = {
	.open		= lowpan_ctx_pfx_open,
	.read		= seq_read,
	.write		= lowpan_ctx_pfx_write,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static void lowpan_dev_debugfs_ctx_init(struct net_device *dev,
					struct dentry *ctx, u8 id)
{
	struct lowpan_dev *ldev = lowpan_dev(dev);
	struct dentry *root;
	char buf[32];

	if (WARN_ON_ONCE(id >= LOWPAN_IPHC_CTX_TABLE_SIZE))
		return;

	sprintf(buf, "%d", id);

	root = debugfs_create_dir(buf, ctx);

	debugfs_create_file("active", 0644, root, &ldev->ctx.table[id],
			    &lowpan_ctx_flag_active_fops);

	debugfs_create_file("compression", 0644, root, &ldev->ctx.table[id],
			    &lowpan_ctx_flag_c_fops);

	debugfs_create_file("prefix", 0644, root, &ldev->ctx.table[id],
			    &lowpan_ctx_pfx_fops);

	debugfs_create_file("prefix_len", 0644, root, &ldev->ctx.table[id],
			    &lowpan_ctx_plen_fops);
}

static int lowpan_context_show(struct seq_file *file, void *offset)
{
	struct lowpan_iphc_ctx_table *t = file->private;
	int i;

	seq_printf(file, "%3s|%-43s|%c\n", "cid", "prefix", 'C');
	seq_puts(file, "-------------------------------------------------\n");

	spin_lock_bh(&t->lock);
	for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++) {
		if (!lowpan_iphc_ctx_is_active(&t->table[i]))
			continue;

		seq_printf(file, "%3d|%39pI6c/%-3d|%d\n", t->table[i].id,
			   &t->table[i].pfx, t->table[i].plen,
			   lowpan_iphc_ctx_is_compression(&t->table[i]));
	}
	spin_unlock_bh(&t->lock);

	return 0;
}
DEFINE_SHOW_ATTRIBUTE(lowpan_context);

static int lowpan_short_addr_get(void *data, u64 *val)
{
	struct wpan_dev *wdev = data;

	rtnl_lock();
	*val = le16_to_cpu(wdev->short_addr);
	rtnl_unlock();

	return 0;
}

DEFINE_DEBUGFS_ATTRIBUTE(lowpan_short_addr_fops, lowpan_short_addr_get, NULL,
			 "0x%04llx\n");

static void lowpan_dev_debugfs_802154_init(const struct net_device *dev,
					  struct lowpan_dev *ldev)
{
	struct dentry *root;

	if (!lowpan_is_ll(dev, LOWPAN_LLTYPE_IEEE802154))
		return;

	root = debugfs_create_dir("ieee802154", ldev->iface_debugfs);

	debugfs_create_file("short_addr", 0444, root,
			    lowpan_802154_dev(dev)->wdev->ieee802154_ptr,
			    &lowpan_short_addr_fops);
}

void lowpan_dev_debugfs_init(struct net_device *dev)
{
	struct lowpan_dev *ldev = lowpan_dev(dev);
	struct dentry *contexts;
	int i;

	/* creating the root */
	ldev->iface_debugfs = debugfs_create_dir(dev->name, lowpan_debugfs);

	contexts = debugfs_create_dir("contexts", ldev->iface_debugfs);

	debugfs_create_file("show", 0644, contexts, &lowpan_dev(dev)->ctx,
			    &lowpan_context_fops);

	for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++)
		lowpan_dev_debugfs_ctx_init(dev, contexts, i);

	lowpan_dev_debugfs_802154_init(dev, ldev);
}

void lowpan_dev_debugfs_exit(struct net_device *dev)
{
	debugfs_remove_recursive(lowpan_dev(dev)->iface_debugfs);
}

void __init lowpan_debugfs_init(void)
{
	lowpan_debugfs = debugfs_create_dir("6lowpan", NULL);
}

void lowpan_debugfs_exit(void)
{
	debugfs_remove_recursive(lowpan_debugfs);
}
Commit	Line	Data
1802d0be TG	1	// SPDX-License-Identifier: GPL-2.0-only
1802d0be TG	2	/*
b1815fd9 AA	3	*
	4	* Authors:
	5	* (C) 2015 Pengutronix, Alexander Aring <aar@pengutronix.de>
	6	* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
	7	*/
	8
	9	#include <net/6lowpan.h>
	10
	11	#include "6lowpan_i.h"
	12
5609c185 AA	13	#define LOWPAN_DEBUGFS_CTX_PFX_NUM_ARGS 8
5609c185 AA	14
b1815fd9 AA	15	static struct dentry *lowpan_debugfs;
b1815fd9 AA	16
5609c185 AA	17	static int lowpan_ctx_flag_active_set(void *data, u64 val)
	18	{
	19	struct lowpan_iphc_ctx *ctx = data;
	20
	21	if (val != 0 && val != 1)
	22	return -EINVAL;
	23
	24	if (val)
	25	set_bit(LOWPAN_IPHC_CTX_FLAG_ACTIVE, &ctx->flags);
	26	else
	27	clear_bit(LOWPAN_IPHC_CTX_FLAG_ACTIVE, &ctx->flags);
	28
	29	return 0;
	30	}
	31
	32	static int lowpan_ctx_flag_active_get(void data, u64 val)
	33	{
	34	*val = lowpan_iphc_ctx_is_active(data);
	35	return 0;
	36	}
	37
5e053534 Y	38	DEFINE_DEBUGFS_ATTRIBUTE(lowpan_ctx_flag_active_fops,
	39	lowpan_ctx_flag_active_get,
	40	lowpan_ctx_flag_active_set, "%llu\n");
5609c185 AA	41
	42	static int lowpan_ctx_flag_c_set(void *data, u64 val)
	43	{
	44	struct lowpan_iphc_ctx *ctx = data;
	45
	46	if (val != 0 && val != 1)
	47	return -EINVAL;
	48
	49	if (val)
	50	set_bit(LOWPAN_IPHC_CTX_FLAG_COMPRESSION, &ctx->flags);
	51	else
	52	clear_bit(LOWPAN_IPHC_CTX_FLAG_COMPRESSION, &ctx->flags);
	53
	54	return 0;
	55	}
	56
	57	static int lowpan_ctx_flag_c_get(void data, u64 val)
	58	{
	59	*val = lowpan_iphc_ctx_is_compression(data);
	60	return 0;
	61	}
	62
5e053534 Y	63	DEFINE_DEBUGFS_ATTRIBUTE(lowpan_ctx_flag_c_fops, lowpan_ctx_flag_c_get,
5e053534 Y	64	lowpan_ctx_flag_c_set, "%llu\n");
5609c185 AA	65
	66	static int lowpan_ctx_plen_set(void *data, u64 val)
	67	{
	68	struct lowpan_iphc_ctx *ctx = data;
	69	struct lowpan_iphc_ctx_table *t =
	70	container_of(ctx, struct lowpan_iphc_ctx_table, table[ctx->id]);
	71
	72	if (val > 128)
	73	return -EINVAL;
	74
	75	spin_lock_bh(&t->lock);
	76	ctx->plen = val;
	77	spin_unlock_bh(&t->lock);
	78
	79	return 0;
	80	}
	81
	82	static int lowpan_ctx_plen_get(void data, u64 val)
	83	{
	84	struct lowpan_iphc_ctx *ctx = data;
	85	struct lowpan_iphc_ctx_table *t =
	86	container_of(ctx, struct lowpan_iphc_ctx_table, table[ctx->id]);
	87
	88	spin_lock_bh(&t->lock);
	89	*val = ctx->plen;
	90	spin_unlock_bh(&t->lock);
	91	return 0;
	92	}
	93
5e053534 Y	94	DEFINE_DEBUGFS_ATTRIBUTE(lowpan_ctx_plen_fops, lowpan_ctx_plen_get,
5e053534 Y	95	lowpan_ctx_plen_set, "%llu\n");
5609c185 AA	96
	97	static int lowpan_ctx_pfx_show(struct seq_file file, void offset)
	98	{
	99	struct lowpan_iphc_ctx *ctx = file->private;
	100	struct lowpan_iphc_ctx_table *t =
	101	container_of(ctx, struct lowpan_iphc_ctx_table, table[ctx->id]);
	102
	103	spin_lock_bh(&t->lock);
	104	seq_printf(file, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
	105	be16_to_cpu(ctx->pfx.s6_addr16[0]),
	106	be16_to_cpu(ctx->pfx.s6_addr16[1]),
	107	be16_to_cpu(ctx->pfx.s6_addr16[2]),
	108	be16_to_cpu(ctx->pfx.s6_addr16[3]),
	109	be16_to_cpu(ctx->pfx.s6_addr16[4]),
	110	be16_to_cpu(ctx->pfx.s6_addr16[5]),
	111	be16_to_cpu(ctx->pfx.s6_addr16[6]),
	112	be16_to_cpu(ctx->pfx.s6_addr16[7]));
	113	spin_unlock_bh(&t->lock);
	114
	115	return 0;
	116	}
	117
	118	static int lowpan_ctx_pfx_open(struct inode inode, struct file file)
	119	{
	120	return single_open(file, lowpan_ctx_pfx_show, inode->i_private);
	121	}
	122
	123	static ssize_t lowpan_ctx_pfx_write(struct file *fp,
	124	const char __user *user_buf, size_t count,
	125	loff_t *ppos)
	126	{
	127	char buf[128] = {};
	128	struct seq_file *file = fp->private_data;
	129	struct lowpan_iphc_ctx *ctx = file->private;
	130	struct lowpan_iphc_ctx_table *t =
	131	container_of(ctx, struct lowpan_iphc_ctx_table, table[ctx->id]);
	132	int status = count, n, i;
	133	unsigned int addr[8];
	134
	135	if (copy_from_user(&buf, user_buf, min_t(size_t, sizeof(buf) - 1,
	136	count))) {
	137	status = -EFAULT;
	138	goto out;
	139	}
	140
	141	n = sscanf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
	142	&addr[0], &addr[1], &addr[2], &addr[3], &addr[4],
	143	&addr[5], &addr[6], &addr[7]);
	144	if (n != LOWPAN_DEBUGFS_CTX_PFX_NUM_ARGS) {
	145	status = -EINVAL;
	146	goto out;
	147	}
	148
	149	spin_lock_bh(&t->lock);
	150	for (i = 0; i < 8; i++)
	151	ctx->pfx.s6_addr16[i] = cpu_to_be16(addr[i] & 0xffff);
	152	spin_unlock_bh(&t->lock);
	153
	154	out:
	155	return status;
	156	}
	157
6aaf37b4	158	static const struct file_operations lowpan_ctx_pfx_fops = {
5609c185 AA	159	.open = lowpan_ctx_pfx_open,
	160	.read = seq_read,
	161	.write = lowpan_ctx_pfx_write,
	162	.llseek = seq_lseek,
	163	.release = single_release,
	164	};
	165
db50450d GKH	166	static void lowpan_dev_debugfs_ctx_init(struct net_device *dev,
db50450d GKH	167	struct dentry *ctx, u8 id)
5609c185	168	{
2e4d60cb	169	struct lowpan_dev *ldev = lowpan_dev(dev);
db50450d	170	struct dentry *root;
5609c185 AA	171	char buf[32];
5609c185 AA	172
9af41761 CIK	173	if (WARN_ON_ONCE(id >= LOWPAN_IPHC_CTX_TABLE_SIZE))
9af41761 CIK	174	return;
5609c185 AA	175
	176	sprintf(buf, "%d", id);
	177
	178	root = debugfs_create_dir(buf, ctx);
5609c185	179
db50450d GKH	180	debugfs_create_file("active", 0644, root, &ldev->ctx.table[id],
db50450d GKH	181	&lowpan_ctx_flag_active_fops);
5609c185	182
db50450d GKH	183	debugfs_create_file("compression", 0644, root, &ldev->ctx.table[id],
db50450d GKH	184	&lowpan_ctx_flag_c_fops);
5609c185	185
db50450d GKH	186	debugfs_create_file("prefix", 0644, root, &ldev->ctx.table[id],
db50450d GKH	187	&lowpan_ctx_pfx_fops);
5609c185	188
db50450d GKH	189	debugfs_create_file("prefix_len", 0644, root, &ldev->ctx.table[id],
db50450d GKH	190	&lowpan_ctx_plen_fops);
5609c185 AA	191	}
	192
	193	static int lowpan_context_show(struct seq_file file, void offset)
	194	{
	195	struct lowpan_iphc_ctx_table *t = file->private;
	196	int i;
	197
	198	seq_printf(file, "%3s\|%-43s\|%c\n", "cid", "prefix", 'C');
	199	seq_puts(file, "-------------------------------------------------\n");
	200
	201	spin_lock_bh(&t->lock);
	202	for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++) {
	203	if (!lowpan_iphc_ctx_is_active(&t->table[i]))
	204	continue;
	205
	206	seq_printf(file, "%3d\|%39pI6c/%-3d\|%d\n", t->table[i].id,
	207	&t->table[i].pfx, t->table[i].plen,
	208	lowpan_iphc_ctx_is_compression(&t->table[i]));
	209	}
	210	spin_unlock_bh(&t->lock);
	211
	212	return 0;
	213	}
f79ba430	214	DEFINE_SHOW_ATTRIBUTE(lowpan_context);
5609c185	215
cfce9465 AA	216	static int lowpan_short_addr_get(void data, u64 val)
	217	{
	218	struct wpan_dev *wdev = data;
	219
	220	rtnl_lock();
	221	*val = le16_to_cpu(wdev->short_addr);
	222	rtnl_unlock();
	223
	224	return 0;
	225	}
	226
5e053534 Y	227	DEFINE_DEBUGFS_ATTRIBUTE(lowpan_short_addr_fops, lowpan_short_addr_get, NULL,
5e053534 Y	228	"0x%04llx\n");
cfce9465	229
db50450d	230	static void lowpan_dev_debugfs_802154_init(const struct net_device *dev,
cfce9465 AA	231	struct lowpan_dev *ldev)
cfce9465 AA	232	{
db50450d	233	struct dentry *root;
cfce9465 AA	234
cfce9465 AA	235	if (!lowpan_is_ll(dev, LOWPAN_LLTYPE_IEEE802154))
db50450d	236	return;
cfce9465 AA	237
cfce9465 AA	238	root = debugfs_create_dir("ieee802154", ldev->iface_debugfs);
cfce9465	239
db50450d GKH	240	debugfs_create_file("short_addr", 0444, root,
	241	lowpan_802154_dev(dev)->wdev->ieee802154_ptr,
	242	&lowpan_short_addr_fops);
cfce9465 AA	243	}
cfce9465 AA	244
db50450d	245	void lowpan_dev_debugfs_init(struct net_device *dev)
b1815fd9	246	{
2e4d60cb	247	struct lowpan_dev *ldev = lowpan_dev(dev);
db50450d GKH	248	struct dentry *contexts;
db50450d GKH	249	int i;
b1815fd9 AA	250
b1815fd9 AA	251	/* creating the root */
2e4d60cb	252	ldev->iface_debugfs = debugfs_create_dir(dev->name, lowpan_debugfs);
b1815fd9	253
2e4d60cb	254	contexts = debugfs_create_dir("contexts", ldev->iface_debugfs);
5609c185	255
db50450d GKH	256	debugfs_create_file("show", 0644, contexts, &lowpan_dev(dev)->ctx,
db50450d GKH	257	&lowpan_context_fops);
cfce9465	258
db50450d GKH	259	for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++)
db50450d GKH	260	lowpan_dev_debugfs_ctx_init(dev, contexts, i);
b1815fd9	261
db50450d	262	lowpan_dev_debugfs_802154_init(dev, ldev);
b1815fd9 AA	263	}
	264
	265	void lowpan_dev_debugfs_exit(struct net_device *dev)
	266	{
2e4d60cb	267	debugfs_remove_recursive(lowpan_dev(dev)->iface_debugfs);
b1815fd9 AA	268	}
b1815fd9 AA	269
db50450d	270	void __init lowpan_debugfs_init(void)
b1815fd9 AA	271	{
b1815fd9 AA	272	lowpan_debugfs = debugfs_create_dir("6lowpan", NULL);
b1815fd9 AA	273	}
	274
	275	void lowpan_debugfs_exit(void)
	276	{
	277	debugfs_remove_recursive(lowpan_debugfs);
	278	}