bifrost/r38p2/kernel/drivers/gpu/arm/midgard/debug/mali_kbase_debug_ktrace.c - manifest_repos/mali-driver - Git at Google

 // 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 */
	// 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 */