[linux-2.6-block.git] / net / batman-adv / log.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright (C) 2010-2019  B.A.T.M.A.N. contributors:
 *
 * Marek Lindner
 */

#include "log.h"
#include "main.h"

#include <linux/compiler.h>
#include <linux/debugfs.h>
#include <linux/errno.h>
#include <linux/eventpoll.h>
#include <linux/export.h>
#include <linux/fcntl.h>
#include <linux/fs.h>
#include <linux/gfp.h>
#include <linux/jiffies.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/poll.h>
#include <linux/sched.h> /* for linux/wait.h */
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/stddef.h>
#include <linux/types.h>
#include <linux/uaccess.h>
#include <linux/wait.h>
#include <stdarg.h>

#include "debugfs.h"
#include "trace.h"

#ifdef CONFIG_BATMAN_ADV_DEBUGFS

#define BATADV_LOG_BUFF_MASK (batadv_log_buff_len - 1)

static const int batadv_log_buff_len = BATADV_LOG_BUF_LEN;

static char *batadv_log_char_addr(struct batadv_priv_debug_log *debug_log,
				  size_t idx)
{
	return &debug_log->log_buff[idx & BATADV_LOG_BUFF_MASK];
}

static void batadv_emit_log_char(struct batadv_priv_debug_log *debug_log,
				 char c)
{
	char *char_addr;

	char_addr = batadv_log_char_addr(debug_log, debug_log->log_end);
	*char_addr = c;
	debug_log->log_end++;

	if (debug_log->log_end - debug_log->log_start > batadv_log_buff_len)
		debug_log->log_start = debug_log->log_end - batadv_log_buff_len;
}

__printf(2, 3)
static int batadv_fdebug_log(struct batadv_priv_debug_log *debug_log,
			     const char *fmt, ...)
{
	va_list args;
	static char debug_log_buf[256];
	char *p;

	if (!debug_log)
		return 0;

	spin_lock_bh(&debug_log->lock);
	va_start(args, fmt);
	vscnprintf(debug_log_buf, sizeof(debug_log_buf), fmt, args);
	va_end(args);

	for (p = debug_log_buf; *p != 0; p++)
		batadv_emit_log_char(debug_log, *p);

	spin_unlock_bh(&debug_log->lock);

	wake_up(&debug_log->queue_wait);

	return 0;
}

static int batadv_log_open(struct inode *inode, struct file *file)
{
	if (!try_module_get(THIS_MODULE))
		return -EBUSY;

	batadv_debugfs_deprecated(file,
				  "Use tracepoint batadv:batadv_dbg instead\n");

	stream_open(inode, file);
	file->private_data = inode->i_private;
	return 0;
}

static int batadv_log_release(struct inode *inode, struct file *file)
{
	module_put(THIS_MODULE);
	return 0;
}

static bool batadv_log_empty(struct batadv_priv_debug_log *debug_log)
{
	return !(debug_log->log_start - debug_log->log_end);
}

static ssize_t batadv_log_read(struct file *file, char __user *buf,
			       size_t count, loff_t *ppos)
{
	struct batadv_priv *bat_priv = file->private_data;
	struct batadv_priv_debug_log *debug_log = bat_priv->debug_log;
	int error, i = 0;
	char *char_addr;
	char c;

	if ((file->f_flags & O_NONBLOCK) && batadv_log_empty(debug_log))
		return -EAGAIN;

	if (!buf)
		return -EINVAL;

	if (count == 0)
		return 0;

	if (!access_ok(buf, count))
		return -EFAULT;

	error = wait_event_interruptible(debug_log->queue_wait,
					 (!batadv_log_empty(debug_log)));

	if (error)
		return error;

	spin_lock_bh(&debug_log->lock);

	while ((!error) && (i < count) &&
	       (debug_log->log_start != debug_log->log_end)) {
		char_addr = batadv_log_char_addr(debug_log,
						 debug_log->log_start);
		c = *char_addr;

		debug_log->log_start++;

		spin_unlock_bh(&debug_log->lock);

		error = __put_user(c, buf);

		spin_lock_bh(&debug_log->lock);

		buf++;
		i++;
	}

	spin_unlock_bh(&debug_log->lock);

	if (!error)
		return i;

	return error;
}

static __poll_t batadv_log_poll(struct file *file, poll_table *wait)
{
	struct batadv_priv *bat_priv = file->private_data;
	struct batadv_priv_debug_log *debug_log = bat_priv->debug_log;

	poll_wait(file, &debug_log->queue_wait, wait);

	if (!batadv_log_empty(debug_log))
		return EPOLLIN | EPOLLRDNORM;

	return 0;
}

static const struct file_operations batadv_log_fops = {
	.open           = batadv_log_open,
	.release        = batadv_log_release,
	.read           = batadv_log_read,
	.poll           = batadv_log_poll,
	.llseek         = no_llseek,
};

/**
 * batadv_debug_log_setup() - Initialize debug log
 * @bat_priv: the bat priv with all the soft interface information
 *
 * Return: 0 on success or negative error number in case of failure
 */
int batadv_debug_log_setup(struct batadv_priv *bat_priv)
{
	bat_priv->debug_log = kzalloc(sizeof(*bat_priv->debug_log), GFP_ATOMIC);
	if (!bat_priv->debug_log)
		return -ENOMEM;

	spin_lock_init(&bat_priv->debug_log->lock);
	init_waitqueue_head(&bat_priv->debug_log->queue_wait);

	debugfs_create_file("log", 0400, bat_priv->debug_dir, bat_priv,
			    &batadv_log_fops);
	return 0;
}

/**
 * batadv_debug_log_cleanup() - Destroy debug log
 * @bat_priv: the bat priv with all the soft interface information
 */
void batadv_debug_log_cleanup(struct batadv_priv *bat_priv)
{
	kfree(bat_priv->debug_log);
	bat_priv->debug_log = NULL;
}

#endif /* CONFIG_BATMAN_ADV_DEBUGFS */

/**
 * batadv_debug_log() - Add debug log entry
 * @bat_priv: the bat priv with all the soft interface information
 * @fmt: format string
 *
 * Return: 0 on success or negative error number in case of failure
 */
int batadv_debug_log(struct batadv_priv *bat_priv, const char *fmt, ...)
{
	struct va_format vaf;
	va_list args;

	va_start(args, fmt);

	vaf.fmt = fmt;
	vaf.va = &args;

#ifdef CONFIG_BATMAN_ADV_DEBUGFS
	batadv_fdebug_log(bat_priv->debug_log, "[%10u] %pV",
			  jiffies_to_msecs(jiffies), &vaf);
#endif

	trace_batadv_dbg(bat_priv, &vaf);

	va_end(args);

	return 0;
}
Commit	Line	Data
7db7d9f3	1	// SPDX-License-Identifier: GPL-2.0
7a79d717	2	/* Copyright (C) 2010-2019 B.A.T.M.A.N. contributors:
ba412080 SE	3	*
ba412080 SE	4	* Marek Lindner
ba412080 SE	5	*/
	6
	7	#include "log.h"
	8	#include "main.h"
	9
	10	#include <linux/compiler.h>
	11	#include <linux/debugfs.h>
	12	#include <linux/errno.h>
48881ed5	13	#include <linux/eventpoll.h>
ba412080 SE	14	#include <linux/export.h>
	15	#include <linux/fcntl.h>
	16	#include <linux/fs.h>
b92b94ac	17	#include <linux/gfp.h>
ba412080 SE	18	#include <linux/jiffies.h>
	19	#include <linux/kernel.h>
	20	#include <linux/module.h>
	21	#include <linux/poll.h>
	22	#include <linux/sched.h> /* for linux/wait.h */
	23	#include <linux/slab.h>
	24	#include <linux/spinlock.h>
ba412080 SE	25	#include <linux/stddef.h>
	26	#include <linux/types.h>
	27	#include <linux/uaccess.h>
	28	#include <linux/wait.h>
	29	#include <stdarg.h>
	30
00caf6a2	31	#include "debugfs.h"
d331a739	32	#include "trace.h"
00caf6a2	33
0dacc7fa SE	34	#ifdef CONFIG_BATMAN_ADV_DEBUGFS
0dacc7fa SE	35
ba412080 SE	36	#define BATADV_LOG_BUFF_MASK (batadv_log_buff_len - 1)
	37
	38	static const int batadv_log_buff_len = BATADV_LOG_BUF_LEN;
	39
	40	static char batadv_log_char_addr(struct batadv_priv_debug_log debug_log,
	41	size_t idx)
	42	{
	43	return &debug_log->log_buff[idx & BATADV_LOG_BUFF_MASK];
	44	}
	45
	46	static void batadv_emit_log_char(struct batadv_priv_debug_log *debug_log,
	47	char c)
	48	{
	49	char *char_addr;
	50
	51	char_addr = batadv_log_char_addr(debug_log, debug_log->log_end);
	52	*char_addr = c;
	53	debug_log->log_end++;
	54
	55	if (debug_log->log_end - debug_log->log_start > batadv_log_buff_len)
	56	debug_log->log_start = debug_log->log_end - batadv_log_buff_len;
	57	}
	58
	59	__printf(2, 3)
	60	static int batadv_fdebug_log(struct batadv_priv_debug_log *debug_log,
	61	const char *fmt, ...)
	62	{
	63	va_list args;
	64	static char debug_log_buf[256];
	65	char *p;
	66
	67	if (!debug_log)
	68	return 0;
	69
	70	spin_lock_bh(&debug_log->lock);
	71	va_start(args, fmt);
	72	vscnprintf(debug_log_buf, sizeof(debug_log_buf), fmt, args);
	73	va_end(args);
	74
	75	for (p = debug_log_buf; *p != 0; p++)
	76	batadv_emit_log_char(debug_log, *p);
	77
	78	spin_unlock_bh(&debug_log->lock);
	79
	80	wake_up(&debug_log->queue_wait);
	81
	82	return 0;
	83	}
	84
ba412080 SE	85	static int batadv_log_open(struct inode inode, struct file file)
	86	{
	87	if (!try_module_get(THIS_MODULE))
	88	return -EBUSY;
	89
d331a739 SE	90	batadv_debugfs_deprecated(file,
d331a739 SE	91	"Use tracepoint batadv:batadv_dbg instead\n");
00caf6a2	92
c5bf68fe	93	stream_open(inode, file);
ba412080 SE	94	file->private_data = inode->i_private;
	95	return 0;
	96	}
	97
	98	static int batadv_log_release(struct inode inode, struct file file)
	99	{
	100	module_put(THIS_MODULE);
	101	return 0;
	102	}
	103
	104	static bool batadv_log_empty(struct batadv_priv_debug_log *debug_log)
	105	{
	106	return !(debug_log->log_start - debug_log->log_end);
	107	}
	108
	109	static ssize_t batadv_log_read(struct file file, char __user buf,
	110	size_t count, loff_t *ppos)
	111	{
	112	struct batadv_priv *bat_priv = file->private_data;
	113	struct batadv_priv_debug_log *debug_log = bat_priv->debug_log;
	114	int error, i = 0;
	115	char *char_addr;
	116	char c;
	117
	118	if ((file->f_flags & O_NONBLOCK) && batadv_log_empty(debug_log))
	119	return -EAGAIN;
	120
	121	if (!buf)
	122	return -EINVAL;
	123
	124	if (count == 0)
	125	return 0;
	126
96d4f267	127	if (!access_ok(buf, count))
ba412080 SE	128	return -EFAULT;
	129
	130	error = wait_event_interruptible(debug_log->queue_wait,
	131	(!batadv_log_empty(debug_log)));
	132
	133	if (error)
	134	return error;
	135
	136	spin_lock_bh(&debug_log->lock);
	137
	138	while ((!error) && (i < count) &&
	139	(debug_log->log_start != debug_log->log_end)) {
	140	char_addr = batadv_log_char_addr(debug_log,
	141	debug_log->log_start);
	142	c = *char_addr;
	143
	144	debug_log->log_start++;
	145
	146	spin_unlock_bh(&debug_log->lock);
	147
	148	error = __put_user(c, buf);
	149
	150	spin_lock_bh(&debug_log->lock);
	151
	152	buf++;
	153	i++;
	154	}
	155
	156	spin_unlock_bh(&debug_log->lock);
	157
	158	if (!error)
	159	return i;
	160
	161	return error;
	162	}
	163
ade994f4	164	static __poll_t batadv_log_poll(struct file file, poll_table wait)
ba412080 SE	165	{
	166	struct batadv_priv *bat_priv = file->private_data;
	167	struct batadv_priv_debug_log *debug_log = bat_priv->debug_log;
	168
	169	poll_wait(file, &debug_log->queue_wait, wait);
	170
	171	if (!batadv_log_empty(debug_log))
a9a08845	172	return EPOLLIN \| EPOLLRDNORM;
ba412080 SE	173
	174	return 0;
	175	}
	176
	177	static const struct file_operations batadv_log_fops = {
	178	.open = batadv_log_open,
	179	.release = batadv_log_release,
	180	.read = batadv_log_read,
	181	.poll = batadv_log_poll,
	182	.llseek = no_llseek,
	183	};
	184
ff15c27c SE	185	/**
	186	* batadv_debug_log_setup() - Initialize debug log
	187	* @bat_priv: the bat priv with all the soft interface information
	188	*
	189	* Return: 0 on success or negative error number in case of failure
	190	*/
ba412080 SE	191	int batadv_debug_log_setup(struct batadv_priv *bat_priv)
ba412080 SE	192	{
ba412080 SE	193	bat_priv->debug_log = kzalloc(sizeof(*bat_priv->debug_log), GFP_ATOMIC);
ba412080 SE	194	if (!bat_priv->debug_log)
3bcacd1e	195	return -ENOMEM;
ba412080 SE	196
	197	spin_lock_init(&bat_priv->debug_log->lock);
	198	init_waitqueue_head(&bat_priv->debug_log->queue_wait);
	199
3bcacd1e GKH	200	debugfs_create_file("log", 0400, bat_priv->debug_dir, bat_priv,
3bcacd1e GKH	201	&batadv_log_fops);
ba412080	202	return 0;
ba412080 SE	203	}
ba412080 SE	204
ff15c27c SE	205	/**
	206	* batadv_debug_log_cleanup() - Destroy debug log
	207	* @bat_priv: the bat priv with all the soft interface information
	208	*/
ba412080 SE	209	void batadv_debug_log_cleanup(struct batadv_priv *bat_priv)
	210	{
	211	kfree(bat_priv->debug_log);
	212	bat_priv->debug_log = NULL;
	213	}
0dacc7fa SE	214
	215	#endif /* CONFIG_BATMAN_ADV_DEBUGFS */
	216
	217	/**
	218	* batadv_debug_log() - Add debug log entry
	219	* @bat_priv: the bat priv with all the soft interface information
	220	* @fmt: format string
	221	*
	222	* Return: 0 on success or negative error number in case of failure
	223	*/
	224	int batadv_debug_log(struct batadv_priv bat_priv, const char fmt, ...)
	225	{
	226	struct va_format vaf;
	227	va_list args;
	228
	229	va_start(args, fmt);
	230
	231	vaf.fmt = fmt;
	232	vaf.va = &args;
	233
	234	#ifdef CONFIG_BATMAN_ADV_DEBUGFS
	235	batadv_fdebug_log(bat_priv->debug_log, "[%10u] %pV",
	236	jiffies_to_msecs(jiffies), &vaf);
	237	#endif
	238
	239	trace_batadv_dbg(bat_priv, &vaf);
	240
	241	va_end(args);
	242
	243	return 0;
	244	}