src/kernel/linux/v4.19/net/6lowpan/debugfs.c - T800 - Gitiles

 /* This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2
  * as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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_SIMPLE_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_SIMPLE_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_SIMPLE_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 int lowpan_dev_debugfs_ctx_init(struct net_device *dev,
 				       struct dentry *ctx, u8 id)
 {
 	struct lowpan_dev *ldev = lowpan_dev(dev);
 	struct dentry *dentry, *root;
 	char buf[32];

 	WARN_ON_ONCE(id > LOWPAN_IPHC_CTX_TABLE_SIZE);

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

 	root = debugfs_create_dir(buf, ctx);
 	if (!root)
 		return -EINVAL;

 	dentry = debugfs_create_file("active", 0644, root,
 				     &ldev->ctx.table[id],
 				     &lowpan_ctx_flag_active_fops);
 	if (!dentry)
 		return -EINVAL;

 	dentry = debugfs_create_file("compression", 0644, root,
 				     &ldev->ctx.table[id],
 				     &lowpan_ctx_flag_c_fops);
 	if (!dentry)
 		return -EINVAL;

 	dentry = debugfs_create_file("prefix", 0644, root,
 				     &ldev->ctx.table[id],
 				     &lowpan_ctx_pfx_fops);
 	if (!dentry)
 		return -EINVAL;

 	dentry = debugfs_create_file("prefix_len", 0644, root,
 				     &ldev->ctx.table[id],
 				     &lowpan_ctx_plen_fops);
 	if (!dentry)
 		return -EINVAL;

 	return 0;
 }

 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;
 }

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

 static const struct file_operations lowpan_context_fops = {
 	.open		= lowpan_context_open,
 	.read		= seq_read,
 	.llseek		= seq_lseek,
 	.release	= single_release,
 };

 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_SIMPLE_ATTRIBUTE(lowpan_short_addr_fops, lowpan_short_addr_get,
 			NULL, "0x%04llx\n");

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

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

 	root = debugfs_create_dir("ieee802154", ldev->iface_debugfs);
 	if (!root)
 		return -EINVAL;

 	dentry = debugfs_create_file("short_addr", 0444, root,
 				     lowpan_802154_dev(dev)->wdev->ieee802154_ptr,
 				     &lowpan_short_addr_fops);
 	if (!dentry)
 		return -EINVAL;

 	return 0;
 }

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

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

 	contexts = debugfs_create_dir("contexts", ldev->iface_debugfs);
 	if (!contexts)
 		goto remove_root;

 	dentry = debugfs_create_file("show", 0644, contexts,
 				     &lowpan_dev(dev)->ctx,
 				     &lowpan_context_fops);
 	if (!dentry)
 		goto remove_root;

 	for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++) {
 		ret = lowpan_dev_debugfs_ctx_init(dev, contexts, i);
 		if (ret < 0)
 			goto remove_root;
 	}

 	ret = lowpan_dev_debugfs_802154_init(dev, ldev);
 	if (ret < 0)
 		goto remove_root;

 	return 0;

 remove_root:
 	lowpan_dev_debugfs_exit(dev);
 fail:
 	return -EINVAL;
 }

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

 int __init lowpan_debugfs_init(void)
 {
 	lowpan_debugfs = debugfs_create_dir("6lowpan", NULL);
 	if (!lowpan_debugfs)
 		return -EINVAL;

 	return 0;
 }

 void lowpan_debugfs_exit(void)
 {
 	debugfs_remove_recursive(lowpan_debugfs);
 }
	/* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2
	* as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* 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_SIMPLE_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_SIMPLE_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_SIMPLE_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 int lowpan_dev_debugfs_ctx_init(struct net_device *dev,
	struct dentry *ctx, u8 id)
	{
	struct lowpan_dev *ldev = lowpan_dev(dev);
	struct dentry dentry, root;
	char buf[32];

	WARN_ON_ONCE(id > LOWPAN_IPHC_CTX_TABLE_SIZE);

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

	root = debugfs_create_dir(buf, ctx);
	if (!root)
	return -EINVAL;

	dentry = debugfs_create_file("active", 0644, root,
	&ldev->ctx.table[id],
	&lowpan_ctx_flag_active_fops);
	if (!dentry)
	return -EINVAL;

	dentry = debugfs_create_file("compression", 0644, root,
	&ldev->ctx.table[id],
	&lowpan_ctx_flag_c_fops);
	if (!dentry)
	return -EINVAL;

	dentry = debugfs_create_file("prefix", 0644, root,
	&ldev->ctx.table[id],
	&lowpan_ctx_pfx_fops);
	if (!dentry)
	return -EINVAL;

	dentry = debugfs_create_file("prefix_len", 0644, root,
	&ldev->ctx.table[id],
	&lowpan_ctx_plen_fops);
	if (!dentry)
	return -EINVAL;

	return 0;
	}

	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;
	}

	static int lowpan_context_open(struct inode inode, struct file file)
	{
	return single_open(file, lowpan_context_show, inode->i_private);
	}

	static const struct file_operations lowpan_context_fops = {
	.open = lowpan_context_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};

	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_SIMPLE_ATTRIBUTE(lowpan_short_addr_fops, lowpan_short_addr_get,
	NULL, "0x%04llx\n");

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

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

	root = debugfs_create_dir("ieee802154", ldev->iface_debugfs);
	if (!root)
	return -EINVAL;

	dentry = debugfs_create_file("short_addr", 0444, root,
	lowpan_802154_dev(dev)->wdev->ieee802154_ptr,
	&lowpan_short_addr_fops);
	if (!dentry)
	return -EINVAL;

	return 0;
	}

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

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

	contexts = debugfs_create_dir("contexts", ldev->iface_debugfs);
	if (!contexts)
	goto remove_root;

	dentry = debugfs_create_file("show", 0644, contexts,
	&lowpan_dev(dev)->ctx,
	&lowpan_context_fops);
	if (!dentry)
	goto remove_root;

	for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++) {
	ret = lowpan_dev_debugfs_ctx_init(dev, contexts, i);
	if (ret < 0)
	goto remove_root;
	}

	ret = lowpan_dev_debugfs_802154_init(dev, ldev);
	if (ret < 0)
	goto remove_root;

	return 0;

	remove_root:
	lowpan_dev_debugfs_exit(dev);
	fail:
	return -EINVAL;
	}

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

	int __init lowpan_debugfs_init(void)
	{
	lowpan_debugfs = debugfs_create_dir("6lowpan", NULL);
	if (!lowpan_debugfs)
	return -EINVAL;

	return 0;
	}

	void lowpan_debugfs_exit(void)
	{
	debugfs_remove_recursive(lowpan_debugfs);
	}