// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2015 MediaTek Inc.
 */

#define DEBUG 1

#include <linux/slab.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>
#include <linux/kallsyms.h>
#include <linux/utsname.h>
#include <linux/uaccess.h>
#include <linux/sched.h>
#include <linux/delay.h>

#include <linux/pid.h>
#include "internal.h"

#include <linux/signal.h>
#include <trace/events/signal.h>

//#define MTK_DEATH_SIGNAL_LOG
//#define MTK_FORK_EXIT_LOG

#define STORE_SIGINFO(_errno, _code, info)			\
	do {							\
		if (info == SEND_SIG_NOINFO ||			\
		    info == SEND_SIG_FORCED) {			\
			_errno	= 0;				\
			_code	= SI_USER;			\
		} else if (info == SEND_SIG_PRIV) {		\
			_errno	= 0;				\
			_code	= SI_KERNEL;			\
		} else {					\
			_errno	= info->si_errno;		\
			_code	= info->si_code;		\
		}						\
	} while (0)

#define SIGNAL_DELIVER_RES_LEN 5
static const char * const signal_deliver_results[] = {
	"delivered",
	"ignored",
	"already_pending",
	"overflow_fail",
	"lost_info",
};

/* 7. signal logs */
MT_DEBUG_ENTRY(signal_log);

enum {
	SI_GENERATE = (1 << 0),
	SI_DELIVER  = (1 << 1),
} SI_LOG_MASK;

#ifndef TASK_STATE_TO_CHAR_STR
#define TASK_STATE_TO_CHAR_STR "RSDTtXZxKWPNn"
#endif

static const char stat_nam[] = TASK_STATE_TO_CHAR_STR;
static unsigned int enabled_signal_log;

static void probe_signal_generate(void *ignore, int sig, struct siginfo *info,
		struct task_struct *task, int group, int result)
{
	unsigned long state = task->state ? __ffs(task->state) + 1 : 0;
	int errno, code;
	bool res_state = true;
	/*
	 * only log delivered signals
	 */
	STORE_SIGINFO(errno, code, info);

	if (result < 0 || result >= SIGNAL_DELIVER_RES_LEN)
		res_state = false;

	printk_deferred("[signal][%d:%s]generate sig %d to [%d:%s:%c] errno=%d code=%d grp=%d res=%s\n",
		current->pid, current->comm, sig,
		task->pid, task->comm,
		state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?',
		errno, code, group,
		res_state ? signal_deliver_results[result] : "?");
}

static void probe_signal_deliver(void *ignore, int sig, struct siginfo *info,
		struct k_sigaction *ka)
{
	int errno, code;

	STORE_SIGINFO(errno, code, info);
	printk_deferred("[signal]sig %d delivered to [%d:%s] errno=%d code=%d sa_handler=%lx sa_flags=%lx\n",
			sig, current->pid, current->comm, errno, code,
			(unsigned long)ka->sa.sa_handler, ka->sa.sa_flags);
}

#ifdef MTK_DEATH_SIGNAL_LOG
static void probe_death_signal(void *ignore, int sig, struct siginfo *info,
		struct task_struct *task, int _group, int result)
{
	struct signal_struct *signal = task->signal;
	unsigned long state;
	int group;

	/*
	 * all action will cause process coredump or terminate
	 * kernel log reduction: only print delivered signals
	 */
	if (sig_fatal(task, sig) && result == TRACE_SIGNAL_DELIVERED) {
		signal = task->signal;
		group = _group ||
		(signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP));
		/*
		 * kernel log reduction
		 * skip SIGRTMIN because it's used as timer signal
		 * skip if the target thread is already dead
		 */
		if (sig == SIGRTMIN ||
		    (task->state & (TASK_DEAD | EXIT_DEAD | EXIT_ZOMBIE)))
			return;
		/*
		 * Global init gets no signals it doesn't want.
		 * Container-init gets no signals it doesn't want from same
		 * container.
		 *
		 * Note that if global/container-init sees a sig_kernel_only()
		 * signal here, the signal must have been generated internally
		 * or must have come from an ancestor namespace. In either
		 * case, the signal cannot be dropped.
		 */
		if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
				!sig_kernel_only(sig))
			return;

		/*
		 * kernel log reduction
		 * only print process instead of all threads
		 */
		if (group && (task != task->group_leader))
			return;

		state = task->state ? __ffs(task->state) + 1 : 0;

		printk_deferred("[signal][%d:%s]send death sig %d to[%d:%s:%c]\n",
			 current->pid, current->comm,
			 sig, task->pid, task->comm,
			 state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?');
	} else if ((sig_kernel_stop(sig) && result == TRACE_SIGNAL_DELIVERED) ||
		   sig == SIGCONT) {

		/*
		 * kernel log reduction
		 * only print process instead of all threads
		 */
		if (_group && (task != task->group_leader))
			return;

		state = task->state ? __ffs(task->state) + 1 : 0;

		printk_deferred("[signal][%d:%s]send %s sig %d to[%d:%s:%c]\n",
			 current->pid, current->comm,
			 (sig == SIGCONT) ? "continue" : "stop",
			 sig, task->pid, task->comm,
			 state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?');
	}
}
#endif
static int mt_signal_log_show(struct seq_file *m, void *v)
{
	SEQ_printf(m, "%d: debug message for signal being generated\n",
		SI_GENERATE);
	SEQ_printf(m, "%d: debug message for signal being delivered\n",
		SI_DELIVER);
	SEQ_printf(m, "%d: enable all logs\n", SI_GENERATE | SI_DELIVER);
	SEQ_printf(m, "%d\n", enabled_signal_log);
	return 0;
}

static ssize_t mt_signal_log_write(struct file *filp, const char *ubuf,
	   size_t cnt, loff_t *data)
{
	unsigned long val = 0;
	unsigned long update;
	int ret;

	ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
	if (ret)
		return ret;

	update = enabled_signal_log ^ val;
	if (update & SI_GENERATE) {
		if (val & SI_GENERATE)
			register_trace_signal_generate(probe_signal_generate,
				NULL);
		else
			unregister_trace_signal_generate(probe_signal_generate,
				NULL);
	}
	if (update & SI_DELIVER) {
		if (val & SI_DELIVER)
			register_trace_signal_deliver(probe_signal_deliver,
				NULL);
		else
			unregister_trace_signal_deliver(probe_signal_deliver,
				NULL);
	}
	enabled_signal_log = (unsigned int)val;

	return cnt;
}

static void __init init_signal_log(void)
{
	if (enabled_signal_log & SI_GENERATE)
		register_trace_signal_generate(probe_signal_generate, NULL);
	if (enabled_signal_log & SI_DELIVER)
		register_trace_signal_deliver(probe_signal_deliver, NULL);
#ifdef MTK_DEATH_SIGNAL_LOG
	register_trace_signal_generate(probe_death_signal, NULL);
#endif
}

#ifdef MTK_FORK_EXIT_LOG
/* 8. fork & exit logs */
#include <trace/events/sched.h>

MT_DEBUG_ENTRY(fork_exit_log);

enum {
	DO_FORK = (1 << 0),
	DO_EXIT  = (1 << 1),
} FORK_EXIT_LOG_MASK;

static unsigned int enabled_fork_exit_log;

static void probe_sched_fork_time(void *ignore,
	struct task_struct *parent,
	struct task_struct *child, unsigned long long dur)
{
	char parent_comm[TASK_COMM_LEN], child_comm[TASK_COMM_LEN];
	pid_t parent_pid, child_pid;
	unsigned long long fork_time;

	memcpy(parent_comm, parent->comm, TASK_COMM_LEN);
	parent_pid = parent->pid;
	memcpy(child_comm, child->comm, TASK_COMM_LEN);
	child_pid = child->pid;
	fork_time = dur;

	pr_debug("[fork]comm=%s pid=%d fork child_comm=%s child_pid=%d, total fork time=%llu us",
		parent_comm, parent_pid, child_comm, child_pid, fork_time);

}

static void probe_sched_process_exit(void *ignore, struct task_struct *p)
{
	char comm[TASK_COMM_LEN];
	pid_t pid;
	int prio;

	memcpy(comm, p->comm, TASK_COMM_LEN);
	pid = p->pid;
	prio = p->prio;

	pr_debug("[exit]comm=%s pid=%d prio=%d exited", comm, pid, prio);

}

static int mt_fork_exit_log_show(struct seq_file *m, void *v)
{
	SEQ_printf(m, "%d: debug message for fork\n", DO_FORK);
	SEQ_printf(m, "%d: debug message for exit\n", DO_EXIT);
	SEQ_printf(m, "%d: enable all logs\n", DO_FORK | DO_EXIT);
	SEQ_printf(m, "%d\n", enabled_fork_exit_log);
	return 0;
}

static ssize_t mt_fork_exit_log_write(struct file *filp, const char *ubuf,
	   size_t cnt, loff_t *data)
{
	unsigned long val = 0;
	unsigned long update;
	int ret;

	ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
	if (ret)
		return ret;

	update = enabled_fork_exit_log ^ val;

	if (update & DO_FORK) {
		if (val & DO_FORK)
			register_trace_sched_fork_time(probe_sched_fork_time,
				NULL);
		else
			unregister_trace_sched_fork_time(probe_sched_fork_time,
				NULL);
	}

	if (update & DO_EXIT) {
		if (val & DO_EXIT)
			register_trace_sched_process_exit(
				probe_sched_process_exit,
				NULL);
		else
			unregister_trace_sched_process_exit(
				probe_sched_process_exit,
				NULL);
	}
	enabled_fork_exit_log = val;

	return cnt;
}

static void __init init_fork_exit_log(void)
{
	if (enabled_fork_exit_log & DO_FORK)
		register_trace_sched_fork_time(probe_sched_fork_time, NULL);
	if (enabled_fork_exit_log & DO_EXIT)
		register_trace_sched_process_exit(probe_sched_process_exit,
			NULL);
}
#endif

/*-------------------------------------------------------------------*/
static int __init init_mtsched_prof(void)
{
	struct proc_dir_entry *pe;

	if (!proc_mkdir("mtprof", NULL))
		return -1;
	init_signal_log();
	pe = proc_create("mtprof/signal_log", 0664, NULL, &mt_signal_log_fops);
	if (!pe)
		return -ENOMEM;

#ifdef MTK_FORK_EXIT_LOG
	init_fork_exit_log();
	pe = proc_create("mtprof/fork_exit_log", 0664, NULL,
		&mt_fork_exit_log_fops);
	if (!pe)
		return -ENOMEM;
#endif

	return 0;
}

device_initcall(init_mtsched_prof);