blob: f521b47120fb122f0bbbddbf5c5832bea1b3bb5d [file] [log] [blame]
// SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note
/*
*
* (C) COPYRIGHT 2020-2022 ARM Limited. All rights reserved.
*
* This program is free software and is provided to you under the terms of the
* GNU General Public License version 2 as published by the Free Software
* Foundation, and any use by you of this program is subject to the terms
* of such GNU license.
*
* 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.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you can access it online at
* http://www.gnu.org/licenses/gpl-2.0.html.
*
*/
#include <mali_kbase.h>
#include "debug/mali_kbase_debug_ktrace_internal.h"
int kbase_ktrace_init(struct kbase_device *kbdev)
{
#if KBASE_KTRACE_TARGET_RBUF
struct kbase_ktrace_msg *rbuf;
spin_lock_init(&kbdev->ktrace.lock);
rbuf = kmalloc_array(KBASE_KTRACE_SIZE, sizeof(*rbuf), GFP_KERNEL);
if (!rbuf)
return -EINVAL;
kbdev->ktrace.rbuf = rbuf;
#endif /* KBASE_KTRACE_TARGET_RBUF */
return 0;
}
void kbase_ktrace_term(struct kbase_device *kbdev)
{
#if KBASE_KTRACE_TARGET_RBUF
kfree(kbdev->ktrace.rbuf);
kbdev->ktrace.rbuf = NULL;
#endif /* KBASE_KTRACE_TARGET_RBUF */
}
void kbase_ktrace_hook_wrapper(void *param)
{
struct kbase_device *kbdev = (struct kbase_device *)param;
KBASE_KTRACE_DUMP(kbdev);
}
#if KBASE_KTRACE_TARGET_RBUF
static const char * const kbasep_ktrace_code_string[] = {
/*
* IMPORTANT: USE OF SPECIAL #INCLUDE OF NON-STANDARD HEADER FILE
* THIS MUST BE USED AT THE START OF THE ARRAY
*/
#define KBASE_KTRACE_CODE_MAKE_CODE(X) # X
#include "debug/mali_kbase_debug_ktrace_codes.h"
#undef KBASE_KTRACE_CODE_MAKE_CODE
};
static void kbasep_ktrace_format_header(char *buffer, int sz, s32 written)
{
written += MAX(snprintf(buffer + written, MAX(sz - written, 0),
"secs,thread_id,cpu,code,kctx,"), 0);
kbasep_ktrace_backend_format_header(buffer, sz, &written);
written += MAX(snprintf(buffer + written, MAX(sz - written, 0),
",info_val,ktrace_version=%u.%u",
KBASE_KTRACE_VERSION_MAJOR,
KBASE_KTRACE_VERSION_MINOR), 0);
buffer[sz - 1] = 0;
}
static void kbasep_ktrace_format_msg(struct kbase_ktrace_msg *trace_msg,
char *buffer, int sz)
{
s32 written = 0;
/* Initial part of message:
*
* secs,thread_id,cpu,code,
*/
written += MAX(snprintf(buffer + written, MAX(sz - written, 0),
"%d.%.6d,%d,%d,%s,",
(int)trace_msg->timestamp.tv_sec,
(int)(trace_msg->timestamp.tv_nsec / 1000),
trace_msg->thread_id, trace_msg->cpu,
kbasep_ktrace_code_string[trace_msg->backend.gpu.code]),
0);
/* kctx part: */
if (trace_msg->kctx_tgid) {
written += MAX(snprintf(buffer + written, MAX(sz - written, 0),
"%d_%u",
trace_msg->kctx_tgid, trace_msg->kctx_id), 0);
}
/* Trailing comma */
written += MAX(snprintf(buffer + written, MAX(sz - written, 0),
","), 0);
/* Backend parts */
kbasep_ktrace_backend_format_msg(trace_msg, buffer, sz,
&written);
/* Rest of message:
*
* ,info_val
*
* Note that the last column is empty, it's simply to hold the ktrace
* version in the header
*/
written += MAX(snprintf(buffer + written, MAX(sz - written, 0),
",0x%.16llx",
(unsigned long long)trace_msg->info_val), 0);
buffer[sz - 1] = 0;
}
static void kbasep_ktrace_dump_msg(struct kbase_device *kbdev,
struct kbase_ktrace_msg *trace_msg)
{
char buffer[KTRACE_DUMP_MESSAGE_SIZE];
lockdep_assert_held(&kbdev->ktrace.lock);
kbasep_ktrace_format_msg(trace_msg, buffer, sizeof(buffer));
dev_dbg(kbdev->dev, "%s", buffer);
}
struct kbase_ktrace_msg *kbasep_ktrace_reserve(struct kbase_ktrace *ktrace)
{
struct kbase_ktrace_msg *trace_msg;
lockdep_assert_held(&ktrace->lock);
trace_msg = &ktrace->rbuf[ktrace->next_in];
/* Update the ringbuffer indices */
ktrace->next_in = (ktrace->next_in + 1) & KBASE_KTRACE_MASK;
if (ktrace->next_in == ktrace->first_out)
ktrace->first_out = (ktrace->first_out + 1) & KBASE_KTRACE_MASK;
return trace_msg;
}
void kbasep_ktrace_msg_init(struct kbase_ktrace *ktrace,
struct kbase_ktrace_msg *trace_msg, enum kbase_ktrace_code code,
struct kbase_context *kctx, kbase_ktrace_flag_t flags,
u64 info_val)
{
lockdep_assert_held(&ktrace->lock);
trace_msg->thread_id = task_pid_nr(current);
trace_msg->cpu = task_cpu(current);
ktime_get_real_ts64(&trace_msg->timestamp);
/* No need to store a flag about whether there was a kctx, tgid==0 is
* sufficient
*/
if (kctx) {
trace_msg->kctx_tgid = kctx->tgid;
trace_msg->kctx_id = kctx->id;
} else {
trace_msg->kctx_tgid = 0;
trace_msg->kctx_id = 0;
}
trace_msg->info_val = info_val;
trace_msg->backend.gpu.code = code;
trace_msg->backend.gpu.flags = flags;
}
void kbasep_ktrace_add(struct kbase_device *kbdev, enum kbase_ktrace_code code,
struct kbase_context *kctx, kbase_ktrace_flag_t flags,
u64 info_val)
{
unsigned long irqflags;
struct kbase_ktrace_msg *trace_msg;
if (unlikely(!kbasep_ktrace_initialized(&kbdev->ktrace)))
return;
WARN_ON((flags & ~KBASE_KTRACE_FLAG_COMMON_ALL));
spin_lock_irqsave(&kbdev->ktrace.lock, irqflags);
/* Reserve and update indices */
trace_msg = kbasep_ktrace_reserve(&kbdev->ktrace);
/* Fill the common part of the message (including backend.gpu.flags) */
kbasep_ktrace_msg_init(&kbdev->ktrace, trace_msg, code, kctx, flags,
info_val);
/* Done */
spin_unlock_irqrestore(&kbdev->ktrace.lock, irqflags);
}
static void kbasep_ktrace_clear_locked(struct kbase_device *kbdev)
{
lockdep_assert_held(&kbdev->ktrace.lock);
kbdev->ktrace.first_out = kbdev->ktrace.next_in;
}
void kbasep_ktrace_clear(struct kbase_device *kbdev)
{
unsigned long flags;
spin_lock_irqsave(&kbdev->ktrace.lock, flags);
kbasep_ktrace_clear_locked(kbdev);
spin_unlock_irqrestore(&kbdev->ktrace.lock, flags);
}
void kbasep_ktrace_dump(struct kbase_device *kbdev)
{
unsigned long flags;
u32 start;
u32 end;
char buffer[KTRACE_DUMP_MESSAGE_SIZE] = "Dumping trace:\n";
kbasep_ktrace_format_header(buffer, sizeof(buffer), strlen(buffer));
dev_dbg(kbdev->dev, "%s", buffer);
spin_lock_irqsave(&kbdev->ktrace.lock, flags);
start = kbdev->ktrace.first_out;
end = kbdev->ktrace.next_in;
while (start != end) {
struct kbase_ktrace_msg *trace_msg = &kbdev->ktrace.rbuf[start];
kbasep_ktrace_dump_msg(kbdev, trace_msg);
start = (start + 1) & KBASE_KTRACE_MASK;
}
dev_dbg(kbdev->dev, "TRACE_END");
kbasep_ktrace_clear_locked(kbdev);
spin_unlock_irqrestore(&kbdev->ktrace.lock, flags);
}
#if IS_ENABLED(CONFIG_DEBUG_FS)
struct trace_seq_state {
struct kbase_ktrace_msg trace_buf[KBASE_KTRACE_SIZE];
u32 start;
u32 end;
};
static void *kbasep_ktrace_seq_start(struct seq_file *s, loff_t *pos)
{
struct trace_seq_state *state = s->private;
int i;
if (*pos == 0)
/* See Documentation/filesystems/seq_file.txt */
return SEQ_START_TOKEN;
if (*pos > KBASE_KTRACE_SIZE)
return NULL;
i = state->start + *pos;
if ((state->end >= state->start && i >= state->end) ||
i >= state->end + KBASE_KTRACE_SIZE)
return NULL;
i &= KBASE_KTRACE_MASK;
return &state->trace_buf[i];
}
static void kbasep_ktrace_seq_stop(struct seq_file *s, void *data)
{
}
static void *kbasep_ktrace_seq_next(struct seq_file *s, void *data, loff_t *pos)
{
struct trace_seq_state *state = s->private;
int i;
if (data != SEQ_START_TOKEN)
(*pos)++;
i = (state->start + *pos) & KBASE_KTRACE_MASK;
if (i == state->end)
return NULL;
return &state->trace_buf[i];
}
static int kbasep_ktrace_seq_show(struct seq_file *s, void *data)
{
struct kbase_ktrace_msg *trace_msg = data;
char buffer[KTRACE_DUMP_MESSAGE_SIZE];
/* If this is the start, print a header */
if (data == SEQ_START_TOKEN)
kbasep_ktrace_format_header(buffer, sizeof(buffer), 0);
else
kbasep_ktrace_format_msg(trace_msg, buffer, sizeof(buffer));
seq_printf(s, "%s\n", buffer);
return 0;
}
static const struct seq_operations kbasep_ktrace_seq_ops = {
.start = kbasep_ktrace_seq_start,
.next = kbasep_ktrace_seq_next,
.stop = kbasep_ktrace_seq_stop,
.show = kbasep_ktrace_seq_show,
};
static int kbasep_ktrace_debugfs_open(struct inode *inode, struct file *file)
{
struct kbase_device *kbdev = inode->i_private;
unsigned long flags;
struct trace_seq_state *state;
state = __seq_open_private(file, &kbasep_ktrace_seq_ops,
sizeof(*state));
if (!state)
return -ENOMEM;
spin_lock_irqsave(&kbdev->ktrace.lock, flags);
state->start = kbdev->ktrace.first_out;
state->end = kbdev->ktrace.next_in;
memcpy(state->trace_buf, kbdev->ktrace.rbuf, sizeof(state->trace_buf));
spin_unlock_irqrestore(&kbdev->ktrace.lock, flags);
return 0;
}
static const struct file_operations kbasep_ktrace_debugfs_fops = {
.owner = THIS_MODULE,
.open = kbasep_ktrace_debugfs_open,
.read = seq_read,
.llseek = seq_lseek,
.release = seq_release_private,
};
void kbase_ktrace_debugfs_init(struct kbase_device *kbdev)
{
debugfs_create_file("mali_trace", 0444,
kbdev->mali_debugfs_directory, kbdev,
&kbasep_ktrace_debugfs_fops);
}
#endif /* CONFIG_DEBUG_FS */
#else /* KBASE_KTRACE_TARGET_RBUF */
#if IS_ENABLED(CONFIG_DEBUG_FS)
void kbase_ktrace_debugfs_init(struct kbase_device *kbdev)
{
CSTD_UNUSED(kbdev);
}
#endif /* CONFIG_DEBUG_FS */
#endif /* KBASE_KTRACE_TARGET_RBUF */