drivers/gpu/drm/msm/sde_dbg_evtlog.c

/* Copyright (c) 2016, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only 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.
 */

#define pr_fmt(fmt)	"sde_evtlog:[%s] " fmt, __func__

#include <linux/delay.h>
#include <linux/spinlock.h>
#include <linux/ktime.h>
#include <linux/debugfs.h>
#include <linux/uaccess.h>
#include <linux/dma-buf.h>

#include "sde_dbg.h"
#include "sde_trace.h"

#ifdef CONFIG_DRM_SDE_EVTLOG_DEBUG
#define SDE_EVTLOG_DEFAULT_ENABLE 1
#else
#define SDE_EVTLOG_DEFAULT_ENABLE 0
#endif

#define SDE_DBG_DEFAULT_PANIC		1

/*
 * evtlog will print this number of entries when it is called through
 * sysfs node or panic. This prevents kernel log from evtlog message
 * flood.
 */
#define SDE_EVTLOG_PRINT_ENTRY	256

/*
 * evtlog keeps this number of entries in memory for debug purpose. This
 * number must be greater than print entry to prevent out of bound evtlog
 * entry array access.
 */
#define SDE_EVTLOG_ENTRY	(SDE_EVTLOG_PRINT_ENTRY * 4)
#define SDE_EVTLOG_MAX_DATA 15
#define SDE_EVTLOG_BUF_MAX 512
#define SDE_EVTLOG_BUF_ALIGN 32

DEFINE_SPINLOCK(sde_evtloglock);

struct tlog {
	u32 counter;
	s64 time;
	const char *name;
	int line;
	u32 data[SDE_EVTLOG_MAX_DATA];
	u32 data_cnt;
	int pid;
};

static struct sde_dbg_evtlog {
	struct tlog logs[SDE_EVTLOG_ENTRY];
	u32 first;
	u32 last;
	u32 curr;
	struct dentry *evtlog;
	u32 evtlog_enable;
	u32 panic_on_err;
	struct work_struct evtlog_dump_work;
	bool work_panic;
} sde_dbg_evtlog;

static inline bool sde_evtlog_is_enabled(u32 flag)
{
	return (flag & sde_dbg_evtlog.evtlog_enable) ||
		(flag == SDE_EVTLOG_ALL && sde_dbg_evtlog.evtlog_enable);
}

void sde_evtlog(const char *name, int line, int flag, ...)
{
	unsigned long flags;
	int i, val = 0;
	va_list args;
	struct tlog *log;

	if (!sde_evtlog_is_enabled(flag))
		return;

	spin_lock_irqsave(&sde_evtloglock, flags);
	log = &sde_dbg_evtlog.logs[sde_dbg_evtlog.curr];
	log->time = ktime_to_us(ktime_get());
	log->name = name;
	log->line = line;
	log->data_cnt = 0;
	log->pid = current->pid;

	va_start(args, flag);
	for (i = 0; i < SDE_EVTLOG_MAX_DATA; i++) {

		val = va_arg(args, int);
		if (val == SDE_EVTLOG_DATA_LIMITER)
			break;

		log->data[i] = val;
	}
	va_end(args);
	log->data_cnt = i;
	sde_dbg_evtlog.curr = (sde_dbg_evtlog.curr + 1) % SDE_EVTLOG_ENTRY;
	sde_dbg_evtlog.last++;

	trace_sde_evtlog(name, line, i > 0 ? log->data[0] : 0,
			i > 1 ? log->data[1] : 0);

	spin_unlock_irqrestore(&sde_evtloglock, flags);
}

/* always dump the last entries which are not dumped yet */
static bool _sde_evtlog_dump_calc_range(void)
{
	static u32 next;
	bool need_dump = true;
	unsigned long flags;
	struct sde_dbg_evtlog *evtlog = &sde_dbg_evtlog;

	spin_lock_irqsave(&sde_evtloglock, flags);

	evtlog->first = next;

	if (evtlog->last == evtlog->first) {
		need_dump = false;
		goto dump_exit;
	}

	if (evtlog->last < evtlog->first) {
		evtlog->first %= SDE_EVTLOG_ENTRY;
		if (evtlog->last < evtlog->first)
			evtlog->last += SDE_EVTLOG_ENTRY;
	}

	if ((evtlog->last - evtlog->first) > SDE_EVTLOG_PRINT_ENTRY) {
		pr_warn("evtlog buffer overflow before dump: %d\n",
			evtlog->last - evtlog->first);
		evtlog->first = evtlog->last - SDE_EVTLOG_PRINT_ENTRY;
	}
	next = evtlog->first + 1;

dump_exit:
	spin_unlock_irqrestore(&sde_evtloglock, flags);

	return need_dump;
}

static ssize_t sde_evtlog_dump_entry(char *evtlog_buf, ssize_t evtlog_buf_size)
{
	int i;
	ssize_t off = 0;
	struct tlog *log, *prev_log;
	unsigned long flags;

	spin_lock_irqsave(&sde_evtloglock, flags);

	log = &sde_dbg_evtlog.logs[sde_dbg_evtlog.first %
		SDE_EVTLOG_ENTRY];

	prev_log = &sde_dbg_evtlog.logs[(sde_dbg_evtlog.first - 1) %
		SDE_EVTLOG_ENTRY];

	off = snprintf((evtlog_buf + off), (evtlog_buf_size - off), "%s:%-4d",
		log->name, log->line);

	if (off < SDE_EVTLOG_BUF_ALIGN) {
		memset((evtlog_buf + off), 0x20, (SDE_EVTLOG_BUF_ALIGN - off));
		off = SDE_EVTLOG_BUF_ALIGN;
	}

	off += snprintf((evtlog_buf + off), (evtlog_buf_size - off),
		"=>[%-8d:%-11llu:%9llu][%-4d]:", sde_dbg_evtlog.first,
		log->time, (log->time - prev_log->time), log->pid);

	for (i = 0; i < log->data_cnt; i++)
		off += snprintf((evtlog_buf + off), (evtlog_buf_size - off),
			"%x ", log->data[i]);

	off += snprintf((evtlog_buf + off), (evtlog_buf_size - off), "\n");

	spin_unlock_irqrestore(&sde_evtloglock, flags);

	return off;
}

static void _sde_evtlog_dump_all(void)
{
	char evtlog_buf[SDE_EVTLOG_BUF_MAX];

	while (_sde_evtlog_dump_calc_range()) {
		sde_evtlog_dump_entry(evtlog_buf, SDE_EVTLOG_BUF_MAX);
		pr_info("%s", evtlog_buf);
	}
}

static void _sde_dump_array(bool dead, const char *name)
{
	_sde_evtlog_dump_all();

	if (dead && sde_dbg_evtlog.panic_on_err)
		panic(name);
}

static void _sde_dump_work(struct work_struct *work)
{
	_sde_dump_array(sde_dbg_evtlog.work_panic, "evtlog_workitem");
}

void sde_dbg_dump(bool queue, const char *name, ...)
{
	int i;
	bool dead = false;
	va_list args;
	char *blk_name = NULL;

	if (!sde_evtlog_is_enabled(SDE_EVTLOG_DEFAULT))
		return;

	if (queue && work_pending(&sde_dbg_evtlog.evtlog_dump_work))
		return;

	va_start(args, name);
	for (i = 0; i < SDE_EVTLOG_MAX_DATA; i++) {
		blk_name = va_arg(args, char*);
		if (IS_ERR_OR_NULL(blk_name))
			break;

		if (!strcmp(blk_name, "panic"))
			dead = true;
	}
	va_end(args);

	if (queue) {
		/* schedule work to dump later */
		sde_dbg_evtlog.work_panic = dead;
		schedule_work(&sde_dbg_evtlog.evtlog_dump_work);
	} else {
		_sde_dump_array(dead, name);
	}
}

static int sde_evtlog_dump_open(struct inode *inode, struct file *file)
{
	/* non-seekable */
	file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
	file->private_data = inode->i_private;
	return 0;
}

static ssize_t sde_evtlog_dump_read(struct file *file, char __user *buff,
		size_t count, loff_t *ppos)
{
	ssize_t len = 0;
	char evtlog_buf[SDE_EVTLOG_BUF_MAX];

	if (_sde_evtlog_dump_calc_range()) {
		len = sde_evtlog_dump_entry(evtlog_buf, SDE_EVTLOG_BUF_MAX);
		if (copy_to_user(buff, evtlog_buf, len))
			return -EFAULT;
		*ppos += len;
	}

	return len;
}

static ssize_t sde_evtlog_dump_write(struct file *file,
	const char __user *user_buf, size_t count, loff_t *ppos)
{
	_sde_evtlog_dump_all();

	if (sde_dbg_evtlog.panic_on_err)
		panic("sde");

	return count;
}

static const struct file_operations sde_evtlog_fops = {
	.open = sde_evtlog_dump_open,
	.read = sde_evtlog_dump_read,
	.write = sde_evtlog_dump_write,
};

int sde_evtlog_init(struct dentry *debugfs_root)
{
	int i;

	sde_dbg_evtlog.evtlog = debugfs_create_dir("evt_dbg", debugfs_root);
	if (IS_ERR_OR_NULL(sde_dbg_evtlog.evtlog)) {
		pr_err("debugfs_create_dir fail, error %ld\n",
		       PTR_ERR(sde_dbg_evtlog.evtlog));
		sde_dbg_evtlog.evtlog = NULL;
		return -ENODEV;
	}

	INIT_WORK(&sde_dbg_evtlog.evtlog_dump_work, _sde_dump_work);
	sde_dbg_evtlog.work_panic = false;

	for (i = 0; i < SDE_EVTLOG_ENTRY; i++)
		sde_dbg_evtlog.logs[i].counter = i;

	debugfs_create_file("dump", 0644, sde_dbg_evtlog.evtlog, NULL,
						&sde_evtlog_fops);
	debugfs_create_u32("enable", 0644, sde_dbg_evtlog.evtlog,
			    &sde_dbg_evtlog.evtlog_enable);
	debugfs_create_u32("panic", 0644, sde_dbg_evtlog.evtlog,
			    &sde_dbg_evtlog.panic_on_err);

	sde_dbg_evtlog.evtlog_enable = SDE_EVTLOG_DEFAULT_ENABLE;
	sde_dbg_evtlog.panic_on_err = SDE_DBG_DEFAULT_PANIC;

	pr_info("evtlog_status: enable:%d, panic:%d\n",
		sde_dbg_evtlog.evtlog_enable, sde_dbg_evtlog.panic_on_err);

	return 0;
}

void sde_evtlog_destroy(void)
{
	debugfs_remove(sde_dbg_evtlog.evtlog);
}