cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

debugfs.c (11035B)


      1// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
      2/*
      3 * Copyright (C) 2012-2014, 2018-2020 Intel Corporation
      4 * Copyright (C) 2013-2015 Intel Mobile Communications GmbH
      5 * Copyright (C) 2016-2017 Intel Deutschland GmbH
      6 */
      7#include "api/commands.h"
      8#include "debugfs.h"
      9#include "dbg.h"
     10#include <linux/seq_file.h>
     11
     12#define FWRT_DEBUGFS_OPEN_WRAPPER(name, buflen, argtype)		\
     13struct dbgfs_##name##_data {						\
     14	argtype *arg;							\
     15	bool read_done;							\
     16	ssize_t rlen;							\
     17	char rbuf[buflen];						\
     18};									\
     19static int _iwl_dbgfs_##name##_open(struct inode *inode,		\
     20				    struct file *file)			\
     21{									\
     22	struct dbgfs_##name##_data *data;				\
     23									\
     24	data = kzalloc(sizeof(*data), GFP_KERNEL);			\
     25	if (!data)							\
     26		return -ENOMEM;						\
     27									\
     28	data->read_done = false;					\
     29	data->arg = inode->i_private;					\
     30	file->private_data = data;					\
     31									\
     32	return 0;							\
     33}
     34
     35#define FWRT_DEBUGFS_READ_WRAPPER(name)					\
     36static ssize_t _iwl_dbgfs_##name##_read(struct file *file,		\
     37					char __user *user_buf,		\
     38					size_t count, loff_t *ppos)	\
     39{									\
     40	struct dbgfs_##name##_data *data = file->private_data;		\
     41									\
     42	if (!data->read_done) {						\
     43		data->read_done = true;					\
     44		data->rlen = iwl_dbgfs_##name##_read(data->arg,		\
     45						     sizeof(data->rbuf),\
     46						     data->rbuf);	\
     47	}								\
     48									\
     49	if (data->rlen < 0)						\
     50		return data->rlen;					\
     51	return simple_read_from_buffer(user_buf, count, ppos,		\
     52				       data->rbuf, data->rlen);		\
     53}
     54
     55static int _iwl_dbgfs_release(struct inode *inode, struct file *file)
     56{
     57	kfree(file->private_data);
     58
     59	return 0;
     60}
     61
     62#define _FWRT_DEBUGFS_READ_FILE_OPS(name, buflen, argtype)		\
     63FWRT_DEBUGFS_OPEN_WRAPPER(name, buflen, argtype)			\
     64FWRT_DEBUGFS_READ_WRAPPER(name)						\
     65static const struct file_operations iwl_dbgfs_##name##_ops = {		\
     66	.read = _iwl_dbgfs_##name##_read,				\
     67	.open = _iwl_dbgfs_##name##_open,				\
     68	.llseek = generic_file_llseek,					\
     69	.release = _iwl_dbgfs_release,					\
     70}
     71
     72#define FWRT_DEBUGFS_WRITE_WRAPPER(name, buflen, argtype)		\
     73static ssize_t _iwl_dbgfs_##name##_write(struct file *file,		\
     74					 const char __user *user_buf,	\
     75					 size_t count, loff_t *ppos)	\
     76{									\
     77	argtype *arg =							\
     78		((struct dbgfs_##name##_data *)file->private_data)->arg;\
     79	char buf[buflen] = {};						\
     80	size_t buf_size = min(count, sizeof(buf) -  1);			\
     81									\
     82	if (copy_from_user(buf, user_buf, buf_size))			\
     83		return -EFAULT;						\
     84									\
     85	return iwl_dbgfs_##name##_write(arg, buf, buf_size);		\
     86}
     87
     88#define _FWRT_DEBUGFS_READ_WRITE_FILE_OPS(name, buflen, argtype)	\
     89FWRT_DEBUGFS_OPEN_WRAPPER(name, buflen, argtype)			\
     90FWRT_DEBUGFS_WRITE_WRAPPER(name, buflen, argtype)			\
     91FWRT_DEBUGFS_READ_WRAPPER(name)						\
     92static const struct file_operations iwl_dbgfs_##name##_ops = {		\
     93	.write = _iwl_dbgfs_##name##_write,				\
     94	.read = _iwl_dbgfs_##name##_read,				\
     95	.open = _iwl_dbgfs_##name##_open,				\
     96	.llseek = generic_file_llseek,					\
     97	.release = _iwl_dbgfs_release,					\
     98}
     99
    100#define _FWRT_DEBUGFS_WRITE_FILE_OPS(name, buflen, argtype)		\
    101FWRT_DEBUGFS_OPEN_WRAPPER(name, buflen, argtype)			\
    102FWRT_DEBUGFS_WRITE_WRAPPER(name, buflen, argtype)			\
    103static const struct file_operations iwl_dbgfs_##name##_ops = {		\
    104	.write = _iwl_dbgfs_##name##_write,				\
    105	.open = _iwl_dbgfs_##name##_open,				\
    106	.llseek = generic_file_llseek,					\
    107	.release = _iwl_dbgfs_release,					\
    108}
    109
    110#define FWRT_DEBUGFS_READ_FILE_OPS(name, bufsz)				\
    111	_FWRT_DEBUGFS_READ_FILE_OPS(name, bufsz, struct iwl_fw_runtime)
    112
    113#define FWRT_DEBUGFS_WRITE_FILE_OPS(name, bufsz)			\
    114	_FWRT_DEBUGFS_WRITE_FILE_OPS(name, bufsz, struct iwl_fw_runtime)
    115
    116#define FWRT_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz)			\
    117	_FWRT_DEBUGFS_READ_WRITE_FILE_OPS(name, bufsz, struct iwl_fw_runtime)
    118
    119#define FWRT_DEBUGFS_ADD_FILE_ALIAS(alias, name, parent, mode) do {	\
    120	debugfs_create_file(alias, mode, parent, fwrt,			\
    121			    &iwl_dbgfs_##name##_ops);			\
    122	} while (0)
    123#define FWRT_DEBUGFS_ADD_FILE(name, parent, mode) \
    124	FWRT_DEBUGFS_ADD_FILE_ALIAS(#name, name, parent, mode)
    125
    126static int iwl_fw_send_timestamp_marker_cmd(struct iwl_fw_runtime *fwrt)
    127{
    128	struct iwl_mvm_marker marker = {
    129		.dw_len = sizeof(struct iwl_mvm_marker) / 4,
    130		.marker_id = MARKER_ID_SYNC_CLOCK,
    131
    132		/* the real timestamp is taken from the ftrace clock
    133		 * this is for finding the match between fw and kernel logs
    134		 */
    135		.timestamp = cpu_to_le64(fwrt->timestamp.seq++),
    136	};
    137
    138	struct iwl_host_cmd hcmd = {
    139		.id = MARKER_CMD,
    140		.flags = CMD_ASYNC,
    141		.data[0] = &marker,
    142		.len[0] = sizeof(marker),
    143	};
    144
    145	return iwl_trans_send_cmd(fwrt->trans, &hcmd);
    146}
    147
    148static int iwl_dbgfs_enabled_severities_write(struct iwl_fw_runtime *fwrt,
    149					      char *buf, size_t count)
    150{
    151	struct iwl_dbg_host_event_cfg_cmd event_cfg;
    152	struct iwl_host_cmd hcmd = {
    153		.id = WIDE_ID(DEBUG_GROUP, HOST_EVENT_CFG),
    154		.flags = CMD_ASYNC,
    155		.data[0] = &event_cfg,
    156		.len[0] = sizeof(event_cfg),
    157	};
    158	u32 enabled_severities;
    159	int ret = kstrtou32(buf, 10, &enabled_severities);
    160
    161	if (ret < 0)
    162		return ret;
    163
    164	event_cfg.enabled_severities = cpu_to_le32(enabled_severities);
    165
    166	ret = iwl_trans_send_cmd(fwrt->trans, &hcmd);
    167	IWL_INFO(fwrt,
    168		 "sent host event cfg with enabled_severities: %u, ret: %d\n",
    169		 enabled_severities, ret);
    170
    171	return ret ?: count;
    172}
    173
    174FWRT_DEBUGFS_WRITE_FILE_OPS(enabled_severities, 16);
    175
    176static void iwl_fw_timestamp_marker_wk(struct work_struct *work)
    177{
    178	int ret;
    179	struct iwl_fw_runtime *fwrt =
    180		container_of(work, struct iwl_fw_runtime, timestamp.wk.work);
    181	unsigned long delay = fwrt->timestamp.delay;
    182
    183	ret = iwl_fw_send_timestamp_marker_cmd(fwrt);
    184	if (!ret && delay)
    185		schedule_delayed_work(&fwrt->timestamp.wk,
    186				      round_jiffies_relative(delay));
    187	else
    188		IWL_INFO(fwrt,
    189			 "stopping timestamp_marker, ret: %d, delay: %u\n",
    190			 ret, jiffies_to_msecs(delay) / 1000);
    191}
    192
    193void iwl_fw_trigger_timestamp(struct iwl_fw_runtime *fwrt, u32 delay)
    194{
    195	IWL_INFO(fwrt,
    196		 "starting timestamp_marker trigger with delay: %us\n",
    197		 delay);
    198
    199	iwl_fw_cancel_timestamp(fwrt);
    200
    201	fwrt->timestamp.delay = msecs_to_jiffies(delay * 1000);
    202
    203	schedule_delayed_work(&fwrt->timestamp.wk,
    204			      round_jiffies_relative(fwrt->timestamp.delay));
    205}
    206
    207static ssize_t iwl_dbgfs_timestamp_marker_write(struct iwl_fw_runtime *fwrt,
    208						char *buf, size_t count)
    209{
    210	int ret;
    211	u32 delay;
    212
    213	ret = kstrtou32(buf, 10, &delay);
    214	if (ret < 0)
    215		return ret;
    216
    217	iwl_fw_trigger_timestamp(fwrt, delay);
    218
    219	return count;
    220}
    221
    222static ssize_t iwl_dbgfs_timestamp_marker_read(struct iwl_fw_runtime *fwrt,
    223					       size_t size, char *buf)
    224{
    225	u32 delay_secs = jiffies_to_msecs(fwrt->timestamp.delay) / 1000;
    226
    227	return scnprintf(buf, size, "%d\n", delay_secs);
    228}
    229
    230FWRT_DEBUGFS_READ_WRITE_FILE_OPS(timestamp_marker, 16);
    231
    232struct hcmd_write_data {
    233	__be32 cmd_id;
    234	__be32 flags;
    235	__be16 length;
    236	u8 data[];
    237} __packed;
    238
    239static ssize_t iwl_dbgfs_send_hcmd_write(struct iwl_fw_runtime *fwrt, char *buf,
    240					 size_t count)
    241{
    242	size_t header_size = (sizeof(u32) * 2 + sizeof(u16)) * 2;
    243	size_t data_size = (count - 1) / 2;
    244	int ret;
    245	struct hcmd_write_data *data;
    246	struct iwl_host_cmd hcmd = {
    247		.len = { 0, },
    248		.data = { NULL, },
    249	};
    250
    251	if (fwrt->ops && fwrt->ops->fw_running &&
    252	    !fwrt->ops->fw_running(fwrt->ops_ctx))
    253		return -EIO;
    254
    255	if (count < header_size + 1 || count > 1024 * 4)
    256		return -EINVAL;
    257
    258	data = kmalloc(data_size, GFP_KERNEL);
    259	if (!data)
    260		return -ENOMEM;
    261
    262	ret = hex2bin((u8 *)data, buf, data_size);
    263	if (ret)
    264		goto out;
    265
    266	hcmd.id = be32_to_cpu(data->cmd_id);
    267	hcmd.flags = be32_to_cpu(data->flags);
    268	hcmd.len[0] = be16_to_cpu(data->length);
    269	hcmd.data[0] = data->data;
    270
    271	if (count != header_size + hcmd.len[0] * 2 + 1) {
    272		IWL_ERR(fwrt,
    273			"host command data size does not match header length\n");
    274		ret = -EINVAL;
    275		goto out;
    276	}
    277
    278	if (fwrt->ops && fwrt->ops->send_hcmd)
    279		ret = fwrt->ops->send_hcmd(fwrt->ops_ctx, &hcmd);
    280	else
    281		ret = -EPERM;
    282
    283	if (ret < 0)
    284		goto out;
    285
    286	if (hcmd.flags & CMD_WANT_SKB)
    287		iwl_free_resp(&hcmd);
    288out:
    289	kfree(data);
    290	return ret ?: count;
    291}
    292
    293FWRT_DEBUGFS_WRITE_FILE_OPS(send_hcmd, 512);
    294
    295static ssize_t iwl_dbgfs_fw_dbg_domain_read(struct iwl_fw_runtime *fwrt,
    296					    size_t size, char *buf)
    297{
    298	return scnprintf(buf, size, "0x%08x\n",
    299			 fwrt->trans->dbg.domains_bitmap);
    300}
    301
    302FWRT_DEBUGFS_READ_FILE_OPS(fw_dbg_domain, 20);
    303
    304struct iwl_dbgfs_fw_info_priv {
    305	struct iwl_fw_runtime *fwrt;
    306};
    307
    308struct iwl_dbgfs_fw_info_state {
    309	loff_t pos;
    310};
    311
    312static void *iwl_dbgfs_fw_info_seq_next(struct seq_file *seq,
    313					void *v, loff_t *pos)
    314{
    315	struct iwl_dbgfs_fw_info_state *state = v;
    316	struct iwl_dbgfs_fw_info_priv *priv = seq->private;
    317	const struct iwl_fw *fw = priv->fwrt->fw;
    318
    319	*pos = ++state->pos;
    320	if (*pos >= fw->ucode_capa.n_cmd_versions)
    321		return NULL;
    322
    323	return state;
    324}
    325
    326static void iwl_dbgfs_fw_info_seq_stop(struct seq_file *seq,
    327				       void *v)
    328{
    329	kfree(v);
    330}
    331
    332static void *iwl_dbgfs_fw_info_seq_start(struct seq_file *seq, loff_t *pos)
    333{
    334	struct iwl_dbgfs_fw_info_priv *priv = seq->private;
    335	const struct iwl_fw *fw = priv->fwrt->fw;
    336	struct iwl_dbgfs_fw_info_state *state;
    337
    338	if (*pos >= fw->ucode_capa.n_cmd_versions)
    339		return NULL;
    340
    341	state = kzalloc(sizeof(*state), GFP_KERNEL);
    342	if (!state)
    343		return NULL;
    344	state->pos = *pos;
    345	return state;
    346};
    347
    348static int iwl_dbgfs_fw_info_seq_show(struct seq_file *seq, void *v)
    349{
    350	struct iwl_dbgfs_fw_info_state *state = v;
    351	struct iwl_dbgfs_fw_info_priv *priv = seq->private;
    352	const struct iwl_fw *fw = priv->fwrt->fw;
    353	const struct iwl_fw_cmd_version *ver;
    354	u32 cmd_id;
    355
    356	if (!state->pos)
    357		seq_puts(seq, "fw_api_ver:\n");
    358
    359	ver = &fw->ucode_capa.cmd_versions[state->pos];
    360
    361	cmd_id = WIDE_ID(ver->group, ver->cmd);
    362
    363	seq_printf(seq, "  0x%04x:\n", cmd_id);
    364	seq_printf(seq, "    name: %s\n",
    365		   iwl_get_cmd_string(priv->fwrt->trans, cmd_id));
    366	seq_printf(seq, "    cmd_ver: %d\n", ver->cmd_ver);
    367	seq_printf(seq, "    notif_ver: %d\n", ver->notif_ver);
    368	return 0;
    369}
    370
    371static const struct seq_operations iwl_dbgfs_info_seq_ops = {
    372	.start = iwl_dbgfs_fw_info_seq_start,
    373	.next = iwl_dbgfs_fw_info_seq_next,
    374	.stop = iwl_dbgfs_fw_info_seq_stop,
    375	.show = iwl_dbgfs_fw_info_seq_show,
    376};
    377
    378static int iwl_dbgfs_fw_info_open(struct inode *inode, struct file *filp)
    379{
    380	struct iwl_dbgfs_fw_info_priv *priv;
    381
    382	priv = __seq_open_private(filp, &iwl_dbgfs_info_seq_ops,
    383				  sizeof(*priv));
    384
    385	if (!priv)
    386		return -ENOMEM;
    387
    388	priv->fwrt = inode->i_private;
    389	return 0;
    390}
    391
    392static const struct file_operations iwl_dbgfs_fw_info_ops = {
    393	.owner = THIS_MODULE,
    394	.open = iwl_dbgfs_fw_info_open,
    395	.read = seq_read,
    396	.llseek = seq_lseek,
    397	.release = seq_release_private,
    398};
    399
    400void iwl_fwrt_dbgfs_register(struct iwl_fw_runtime *fwrt,
    401			    struct dentry *dbgfs_dir)
    402{
    403	INIT_DELAYED_WORK(&fwrt->timestamp.wk, iwl_fw_timestamp_marker_wk);
    404	FWRT_DEBUGFS_ADD_FILE(timestamp_marker, dbgfs_dir, 0200);
    405	FWRT_DEBUGFS_ADD_FILE(fw_info, dbgfs_dir, 0200);
    406	FWRT_DEBUGFS_ADD_FILE(send_hcmd, dbgfs_dir, 0200);
    407	FWRT_DEBUGFS_ADD_FILE(enabled_severities, dbgfs_dir, 0200);
    408	FWRT_DEBUGFS_ADD_FILE(fw_dbg_domain, dbgfs_dir, 0400);
    409}