// SPDX-License-Identifier: MIT/* * Copyright © 2023 Intel Corporation */ #include "xe_devcoredump.h"#include "xe_devcoredump_types.h" #include <linux/ascii85.h>#include <linux/devcoredump.h>#include <linux/utsname.h> #include <drm/drm_managed.h> #include "xe_device.h"#include "xe_exec_queue.h"#include "xe_force_wake.h"#include "xe_gt_printk.h"#include "xe_gt_types.h"#include "xe_guc_capture.h"#include "xe_guc_ct.h"#include "xe_guc_log.h"#include "xe_guc_submit.h"#include "xe_hw_engine.h"#include "xe_pm.h"#include "xe_sched_job.h"#include "xe_vm.h" /** * DOC: Xe device coredump * * Xe uses dev_coredump infrastructure for exposing the crash errors in a * standardized way. Once a crash occurs, devcoredump exposes a temporary * node under ``/sys/class/devcoredump/devcd<m>/``. The same node is also * accessible in ``/sys/class/drm/card<n>/device/devcoredump/``. The * ``failing_device`` symlink points to the device that crashed and created the * coredump. * * The following characteristics are observed by xe when creating a device * coredump: * * **Snapshot at hang**: *   The 'data' file contains a snapshot of the HW and driver states at the time *   the hang happened. Due to the driver recovering from resets/crashes, it may *   not correspond to the state of the system when the file is read by *   userspace. * * **Coredump release**: *   After a coredump is generated, it stays in kernel memory until released by *   userspace by writing anything to it, or after an internal timer expires. The *   exact timeout may vary and should not be relied upon. Example to release *   a coredump: * *   .. code-block:: shell * *	$ > /sys/class/drm/card0/device/devcoredump/data * * **First failure only**: *   In general, the first hang is the most critical one since the following *   hangs can be a consequence of the initial hang. For this reason a snapshot *   is taken only for the first failure. Until the devcoredump is released by *   userspace or kernel, all subsequent hangs do not override the snapshot nor *   create new ones. Devcoredump has a delayed work queue that will eventually *   delete the file node and free all the dump information. */ #ifdef CONFIG_DEV_COREDUMP /* 1 hour timeout */#define XE_COREDUMP_TIMEOUT_JIFFIES (60 * 60 * HZ) static struct xe_device *coredump_to_xe(const struct xe_devcoredump *coredump){	return container_of(coredump, struct xe_device, devcoredump);} static struct xe_guc *exec_queue_to_guc(struct xe_exec_queue *q){	return &q->gt->uc.guc;} static ssize_t __xe_devcoredump_read(char *buffer, ssize_t count,				     ssize_t start,				     struct xe_devcoredump *coredump){	struct xe_device *xe;	struct xe_devcoredump_snapshot *ss;	struct drm_printer p;	struct drm_print_iterator iter;	struct timespec64 ts;	int i; 	xe = coredump_to_xe(coredump);	ss = &coredump->snapshot; 	iter.data = buffer;	iter.start = start;	iter.remain = count; 	p = drm_coredump_printer(&iter); 	drm_puts(&p, "**** Xe Device Coredump ****\n");	drm_printf(&p, "Reason: %s\n", ss->reason);	drm_printf(&p, "kernel: %s\n", init_utsname()->release);	drm_puts(&p, "module: " KBUILD_MODNAME "\n"); 	ts = ktime_to_timespec64(ss->snapshot_time);	drm_printf(&p, "Snapshot time: %ptSp\n", &ts);	ts = ktime_to_timespec64(ss->boot_time);	drm_printf(&p, "Uptime: %ptSp\n", &ts);	drm_printf(&p, "Process: %s [%d]\n", ss->process_name, ss->pid);	xe_device_snapshot_print(xe, &p); 	drm_printf(&p, "\n**** GT #%d ****\n", ss->gt->info.id);	drm_printf(&p, "\tTile: %d\n", ss->gt->tile->id); 	drm_puts(&p, "\n**** GuC Log ****\n");	xe_guc_log_snapshot_print(ss->guc.log, &p);	drm_puts(&p, "\n**** GuC CT ****\n");	xe_guc_ct_snapshot_print(ss->guc.ct, &p); 	drm_puts(&p, "\n**** Contexts ****\n");	xe_guc_exec_queue_snapshot_print(ss->ge, &p); 	drm_puts(&p, "\n**** Job ****\n");	xe_sched_job_snapshot_print(ss->job, &p); 	drm_puts(&p, "\n**** HW Engines ****\n");	for (i = 0; i < XE_NUM_HW_ENGINES; i++)		if (ss->hwe[i])			xe_engine_snapshot_print(ss->hwe[i], &p); 	drm_puts(&p, "\n**** VM state ****\n");	xe_vm_snapshot_print(ss->vm, &p); 	return count - iter.remain;} static void xe_devcoredump_snapshot_free(struct xe_devcoredump_snapshot *ss){	int i; 	kfree(ss->reason);	ss->reason = NULL; 	xe_guc_log_snapshot_free(ss->guc.log);	ss->guc.log = NULL; 	xe_guc_ct_snapshot_free(ss->guc.ct);	ss->guc.ct = NULL; 	if (!IS_ERR_OR_NULL(ss->gt))		xe_guc_capture_put_matched_nodes(&ss->gt->uc.guc);	ss->matched_node = NULL; 	xe_guc_exec_queue_snapshot_free(ss->ge);	ss->ge = NULL; 	xe_sched_job_snapshot_free(ss->job);	ss->job = NULL; 	for (i = 0; i < XE_NUM_HW_ENGINES; i++)		if (ss->hwe[i]) {			xe_hw_engine_snapshot_free(ss->hwe[i]);			ss->hwe[i] = NULL;		} 	xe_vm_snapshot_free(ss->vm);	ss->vm = NULL;} #define XE_DEVCOREDUMP_CHUNK_MAX	(SZ_512M + SZ_1G) /** * xe_devcoredump_read() - Read data from the Xe device coredump snapshot * @buffer: Destination buffer to copy the coredump data into * @offset: Offset in the coredump data to start reading from * @count: Number of bytes to read * @data: Pointer to the xe_devcoredump structure * @datalen: Length of the data (unused) * * Reads a chunk of the coredump snapshot data into the provided buffer. * If the devcoredump is smaller than 1.5 GB (XE_DEVCOREDUMP_CHUNK_MAX), * it is read directly from a pre-written buffer. For larger devcoredumps, * the pre-written buffer must be periodically repopulated from the snapshot * state due to kmalloc size limitations. * * Return: Number of bytes copied on success, or a negative error code on failure. */static ssize_t xe_devcoredump_read(char *buffer, loff_t offset,				   size_t count, void *data, size_t datalen){	struct xe_devcoredump *coredump = data;	struct xe_devcoredump_snapshot *ss;	ssize_t byte_copied = 0;	u32 chunk_offset;	ssize_t new_chunk_position;	bool pm_needed = false;	int ret = 0; 	if (!coredump)		return -ENODEV; 	ss = &coredump->snapshot; 	/* Ensure delayed work is captured before continuing */	flush_work(&ss->work); 	pm_needed = ss->read.size > XE_DEVCOREDUMP_CHUNK_MAX;	if (pm_needed)		xe_pm_runtime_get(gt_to_xe(ss->gt)); 	mutex_lock(&coredump->lock); 	if (!ss->read.buffer) {		ret = -ENODEV;		goto unlock;	} 	if (offset >= ss->read.size)		goto unlock; 	new_chunk_position = div_u64_rem(offset,					 XE_DEVCOREDUMP_CHUNK_MAX,					 &chunk_offset); 	if (offset >= ss->read.chunk_position + XE_DEVCOREDUMP_CHUNK_MAX ||	    offset < ss->read.chunk_position) {		ss->read.chunk_position = new_chunk_position *			XE_DEVCOREDUMP_CHUNK_MAX; 		__xe_devcoredump_read(ss->read.buffer,				      XE_DEVCOREDUMP_CHUNK_MAX,				      ss->read.chunk_position, coredump);	} 	byte_copied = count < ss->read.size - offset ? count :		ss->read.size - offset;	memcpy(buffer, ss->read.buffer + chunk_offset, byte_copied); unlock:	mutex_unlock(&coredump->lock); 	if (pm_needed)		xe_pm_runtime_put(gt_to_xe(ss->gt)); 	return byte_copied ? byte_copied : ret;} static void xe_devcoredump_free(void *data){	struct xe_devcoredump *coredump = data; 	/* Our device is gone. Nothing to do... */	if (!data || !coredump_to_xe(coredump))		return; 	if (coredump->captured)		cancel_work_sync(&coredump->snapshot.work); 	mutex_lock(&coredump->lock); 	xe_devcoredump_snapshot_free(&coredump->snapshot);	kvfree(coredump->snapshot.read.buffer); 	/* To prevent stale data on next snapshot, clear everything */	memset(&coredump->snapshot, 0, sizeof(coredump->snapshot));	coredump->captured = false;	drm_info(&coredump_to_xe(coredump)->drm,		 "Xe device coredump has been deleted.\n"); 	mutex_unlock(&coredump->lock);} static void xe_devcoredump_deferred_snap_work(struct work_struct *work){	struct xe_devcoredump_snapshot *ss = container_of(work, typeof(*ss), work);	struct xe_devcoredump *coredump = container_of(ss, typeof(*coredump), snapshot);	struct xe_device *xe = coredump_to_xe(coredump); 	/*	 * NB: Despite passing a GFP_ flags parameter here, more allocations are done	 * internally using GFP_KERNEL explicitly. Hence this call must be in the worker	 * thread and not in the initial capture call.	 */	dev_coredumpm_timeout(gt_to_xe(ss->gt)->drm.dev, THIS_MODULE, coredump, 0, GFP_KERNEL,			      xe_devcoredump_read, xe_devcoredump_free,			      XE_COREDUMP_TIMEOUT_JIFFIES); 	guard(xe_pm_runtime)(xe); 	/* keep going if fw fails as we still want to save the memory and SW data */	xe_with_force_wake(fw_ref, gt_to_fw(ss->gt), XE_FORCEWAKE_ALL) {		if (!xe_force_wake_ref_has_domain(fw_ref.domains, XE_FORCEWAKE_ALL))			xe_gt_info(ss->gt, "failed to get forcewake for coredump capture\n");		xe_vm_snapshot_capture_delayed(ss->vm);		xe_guc_exec_queue_snapshot_capture_delayed(ss->ge);	} 	ss->read.chunk_position = 0; 	/* Calculate devcoredump size */	ss->read.size = __xe_devcoredump_read(NULL, LONG_MAX, 0, coredump); 	if (ss->read.size > XE_DEVCOREDUMP_CHUNK_MAX) {		ss->read.buffer = kvmalloc(XE_DEVCOREDUMP_CHUNK_MAX,					   GFP_USER);		if (!ss->read.buffer)			return; 		__xe_devcoredump_read(ss->read.buffer,				      XE_DEVCOREDUMP_CHUNK_MAX,				      0, coredump);	} else {		ss->read.buffer = kvmalloc(ss->read.size, GFP_USER);		if (!ss->read.buffer)			return; 		__xe_devcoredump_read(ss->read.buffer, ss->read.size, 0,				      coredump);		xe_devcoredump_snapshot_free(ss);	}} static void devcoredump_snapshot(struct xe_devcoredump *coredump,				 struct xe_exec_queue *q,				 struct xe_sched_job *job){	struct xe_devcoredump_snapshot *ss = &coredump->snapshot;	struct xe_guc *guc = exec_queue_to_guc(q);	const char *process_name = "no process";	bool cookie; 	ss->snapshot_time = ktime_get_real();	ss->boot_time = ktime_get_boottime(); 	if (q->vm && q->vm->xef) {		process_name = q->vm->xef->process_name;		ss->pid = q->vm->xef->pid;	} 	strscpy(ss->process_name, process_name); 	ss->gt = q->gt;	INIT_WORK(&ss->work, xe_devcoredump_deferred_snap_work); 	/* keep going if fw fails as we still want to save the memory and SW data */	CLASS(xe_force_wake, fw_ref)(gt_to_fw(q->gt), XE_FORCEWAKE_ALL); 	cookie = dma_fence_begin_signalling(); 	ss->guc.log = xe_guc_log_snapshot_capture(&guc->log, true);	ss->guc.ct = xe_guc_ct_snapshot_capture(&guc->ct);	ss->ge = xe_guc_exec_queue_snapshot_capture(q);	if (job)		ss->job = xe_sched_job_snapshot_capture(job);	ss->vm = xe_vm_snapshot_capture(q->vm); 	xe_engine_snapshot_capture_for_queue(q); 	queue_work(system_dfl_wq, &ss->work); 	dma_fence_end_signalling(cookie);} /** * xe_devcoredump - Take the required snapshots and initialize coredump device. * @q: The faulty xe_exec_queue, where the issue was detected. * @job: The faulty xe_sched_job, where the issue was detected. * @fmt: Printf format + args to describe the reason for the core dump * * This function should be called at the crash time within the serialized * gt_reset. It is skipped if we still have the core dump device available * with the information of the 'first' snapshot. */__printf(3, 4)void xe_devcoredump(struct xe_exec_queue *q, struct xe_sched_job *job, const char *fmt, ...){	struct xe_device *xe = gt_to_xe(q->gt);	struct xe_devcoredump *coredump = &xe->devcoredump;	va_list varg; 	mutex_lock(&coredump->lock); 	if (coredump->captured) {		drm_dbg(&xe->drm, "Multiple hangs are occurring, but only the first snapshot was taken\n");		mutex_unlock(&coredump->lock);		return;	} 	coredump->captured = true; 	va_start(varg, fmt);	coredump->snapshot.reason = kvasprintf(GFP_ATOMIC, fmt, varg);	va_end(varg); 	devcoredump_snapshot(coredump, q, job); 	drm_info(&xe->drm, "Xe device coredump has been created\n");	drm_info(&xe->drm, "Check your /sys/class/drm/card%d/device/devcoredump/data\n",		 xe->drm.primary->index); 	mutex_unlock(&coredump->lock);} static void xe_driver_devcoredump_fini(void *arg){	struct drm_device *drm = arg; 	dev_coredump_put(drm->dev);} int xe_devcoredump_init(struct xe_device *xe){	int err; 	err = drmm_mutex_init(&xe->drm, &xe->devcoredump.lock);	if (err)		return err; 	if (IS_ENABLED(CONFIG_LOCKDEP)) {		fs_reclaim_acquire(GFP_KERNEL);		might_lock(&xe->devcoredump.lock);		fs_reclaim_release(GFP_KERNEL);	} 	return devm_add_action_or_reset(xe->drm.dev, xe_driver_devcoredump_fini, &xe->drm);} #endif /** * xe_print_blob_ascii85 - print a BLOB to some useful location in ASCII85 * * The output is split into multiple calls to drm_puts() because some print * targets, e.g. dmesg, cannot handle arbitrarily long lines. These targets may * add newlines, as is the case with dmesg: each drm_puts() call creates a * separate line. * * There is also a scheduler yield call to prevent the 'task has been stuck for * 120s' kernel hang check feature from firing when printing to a slow target * such as dmesg over a serial port. * * @p: the printer object to output to * @prefix: optional prefix to add to output string * @suffix: optional suffix to add at the end. 0 disables it and is *          not added to the output, which is useful when using multiple calls *          to dump data to @p * @blob: the Binary Large OBject to dump out * @offset: offset in bytes to skip from the front of the BLOB, must be a multiple of sizeof(u32) * @size: the size in bytes of the BLOB, must be a multiple of sizeof(u32) */void xe_print_blob_ascii85(struct drm_printer *p, const char *prefix, char suffix,			   const void *blob, size_t offset, size_t size){	const u32 *blob32 = (const u32 *)blob;	char buff[ASCII85_BUFSZ], *line_buff;	size_t line_pos = 0; #define DMESG_MAX_LINE_LEN	800	/* Always leave space for the suffix char and the \0 */#define MIN_SPACE		(ASCII85_BUFSZ + 2)	/* 85 + "<suffix>\0" */ 	if (size & 3)		drm_printf(p, "Size not word aligned: %zu", size);	if (offset & 3)		drm_printf(p, "Offset not word aligned: %zu", offset); 	line_buff = kzalloc(DMESG_MAX_LINE_LEN, GFP_ATOMIC);	if (!line_buff) {		drm_printf(p, "Failed to allocate line buffer\n");		return;	} 	blob32 += offset / sizeof(*blob32);	size /= sizeof(*blob32); 	if (prefix) {		strscpy(line_buff, prefix, DMESG_MAX_LINE_LEN - MIN_SPACE - 2);		line_pos = strlen(line_buff); 		line_buff[line_pos++] = ':';		line_buff[line_pos++] = ' ';	} 	while (size--) {		u32 val = *(blob32++); 		strscpy(line_buff + line_pos, ascii85_encode(val, buff),			DMESG_MAX_LINE_LEN - line_pos);		line_pos += strlen(line_buff + line_pos); 		if ((line_pos + MIN_SPACE) >= DMESG_MAX_LINE_LEN) {			line_buff[line_pos++] = 0; 			drm_puts(p, line_buff); 			line_pos = 0; 			/* Prevent 'stuck thread' time out errors */

Lines 1–500 of 517. Load more