xe_guc_log.c

  1// SPDX-License-Identifier: MIT
  2/*
  3 * Copyright © 2022 Intel Corporation
  4 */
  5
  6#include "xe_guc_log.h"
  7
  8#include <linux/fault-inject.h>
  9
 10#include <drm/drm_managed.h>
 11
 12#include "regs/xe_guc_regs.h"
 13#include "xe_bo.h"
 14#include "xe_devcoredump.h"
 15#include "xe_force_wake.h"
 16#include "xe_gt.h"
 17#include "xe_gt_printk.h"
 18#include "xe_map.h"
 19#include "xe_mmio.h"
 20#include "xe_module.h"
 21
 22static struct xe_guc *
 23log_to_guc(struct xe_guc_log *log)
 24{
 25	return container_of(log, struct xe_guc, log);
 26}
 27
 28static struct xe_gt *
 29log_to_gt(struct xe_guc_log *log)
 30{
 31	return container_of(log, struct xe_gt, uc.guc.log);
 32}
 33
 34static struct xe_device *
 35log_to_xe(struct xe_guc_log *log)
 36{
 37	return gt_to_xe(log_to_gt(log));
 38}
 39
 40static size_t guc_log_size(void)
 41{
 42	/*
 43	 *  GuC Log buffer Layout
 44	 *
 45	 *  +===============================+ 00B
 46	 *  |    Crash dump state header    |
 47	 *  +-------------------------------+ 32B
 48	 *  |      Debug state header       |
 49	 *  +-------------------------------+ 64B
 50	 *  |     Capture state header      |
 51	 *  +-------------------------------+ 96B
 52	 *  |                               |
 53	 *  +===============================+ PAGE_SIZE (4KB)
 54	 *  |        Crash Dump logs        |
 55	 *  +===============================+ + CRASH_SIZE
 56	 *  |          Debug logs           |
 57	 *  +===============================+ + DEBUG_SIZE
 58	 *  |         Capture logs          |
 59	 *  +===============================+ + CAPTURE_SIZE
 60	 */
 61	return PAGE_SIZE + CRASH_BUFFER_SIZE + DEBUG_BUFFER_SIZE +
 62		CAPTURE_BUFFER_SIZE;
 63}
 64
 65#define GUC_LOG_CHUNK_SIZE	SZ_2M
 66
 67static struct xe_guc_log_snapshot *xe_guc_log_snapshot_alloc(struct xe_guc_log *log, bool atomic)
 68{
 69	struct xe_guc_log_snapshot *snapshot;
 70	size_t remain;
 71	int i;
 72
 73	snapshot = kzalloc(sizeof(*snapshot), atomic ? GFP_ATOMIC : GFP_KERNEL);
 74	if (!snapshot)
 75		return NULL;
 76
 77	/*
 78	 * NB: kmalloc has a hard limit well below the maximum GuC log buffer size.
 79	 * Also, can't use vmalloc as might be called from atomic context. So need
 80	 * to break the buffer up into smaller chunks that can be allocated.
 81	 */
 82	snapshot->size = xe_bo_size(log->bo);
 83	snapshot->num_chunks = DIV_ROUND_UP(snapshot->size, GUC_LOG_CHUNK_SIZE);
 84
 85	snapshot->copy = kcalloc(snapshot->num_chunks, sizeof(*snapshot->copy),
 86				 atomic ? GFP_ATOMIC : GFP_KERNEL);
 87	if (!snapshot->copy)
 88		goto fail_snap;
 89
 90	remain = snapshot->size;
 91	for (i = 0; i < snapshot->num_chunks; i++) {
 92		size_t size = min(GUC_LOG_CHUNK_SIZE, remain);
 93
 94		snapshot->copy[i] = kmalloc(size, atomic ? GFP_ATOMIC : GFP_KERNEL);
 95		if (!snapshot->copy[i])
 96			goto fail_copy;
 97		remain -= size;
 98	}
 99
100	return snapshot;
101
102fail_copy:
103	for (i = 0; i < snapshot->num_chunks; i++)
104		kfree(snapshot->copy[i]);
105	kfree(snapshot->copy);
106fail_snap:
107	kfree(snapshot);
108	return NULL;
109}
110
111/**
112 * xe_guc_log_snapshot_free - free a previously captured GuC log snapshot
113 * @snapshot: GuC log snapshot structure
114 *
115 * Return: pointer to a newly allocated snapshot object or null if out of memory. Caller is
116 * responsible for calling xe_guc_log_snapshot_free when done with the snapshot.
117 */
118void xe_guc_log_snapshot_free(struct xe_guc_log_snapshot *snapshot)
119{
120	int i;
121
122	if (!snapshot)
123		return;
124
125	if (snapshot->copy) {
126		for (i = 0; i < snapshot->num_chunks; i++)
127			kfree(snapshot->copy[i]);
128		kfree(snapshot->copy);
129	}
130
131	kfree(snapshot);
132}
133
134/**
135 * xe_guc_log_snapshot_capture - create a new snapshot copy the GuC log for later dumping
136 * @log: GuC log structure
137 * @atomic: is the call inside an atomic section of some kind?
138 *
139 * Return: pointer to a newly allocated snapshot object or null if out of memory. Caller is
140 * responsible for calling xe_guc_log_snapshot_free when done with the snapshot.
141 */
142struct xe_guc_log_snapshot *xe_guc_log_snapshot_capture(struct xe_guc_log *log, bool atomic)
143{
144	struct xe_guc_log_snapshot *snapshot;
145	struct xe_device *xe = log_to_xe(log);
146	struct xe_guc *guc = log_to_guc(log);
147	struct xe_gt *gt = log_to_gt(log);
148	unsigned int fw_ref;
149	size_t remain;
150	int i;
151
152	if (!log->bo)
153		return NULL;
154
155	snapshot = xe_guc_log_snapshot_alloc(log, atomic);
156	if (!snapshot)
157		return NULL;
158
159	remain = snapshot->size;
160	for (i = 0; i < snapshot->num_chunks; i++) {
161		size_t size = min(GUC_LOG_CHUNK_SIZE, remain);
162
163		xe_map_memcpy_from(xe, snapshot->copy[i], &log->bo->vmap,
164				   i * GUC_LOG_CHUNK_SIZE, size);
165		remain -= size;
166	}
167
168	fw_ref = xe_force_wake_get(gt_to_fw(gt), XE_FW_GT);
169	if (!fw_ref) {
170		snapshot->stamp = ~0ULL;
171	} else {
172		snapshot->stamp = xe_mmio_read64_2x32(&gt->mmio, GUC_PMTIMESTAMP_LO);
173		xe_force_wake_put(gt_to_fw(gt), fw_ref);
174	}
175	snapshot->ktime = ktime_get_boottime_ns();
176	snapshot->level = log->level;
177	snapshot->ver_found = guc->fw.versions.found[XE_UC_FW_VER_RELEASE];
178	snapshot->ver_want = guc->fw.versions.wanted;
179	snapshot->path = guc->fw.path;
180
181	return snapshot;
182}
183
184/**
185 * xe_guc_log_snapshot_print - dump a previously saved copy of the GuC log to some useful location
186 * @snapshot: a snapshot of the GuC log
187 * @p: the printer object to output to
188 */
189void xe_guc_log_snapshot_print(struct xe_guc_log_snapshot *snapshot, struct drm_printer *p)
190{
191	size_t remain;
192	int i;
193
194	if (!snapshot) {
195		drm_printf(p, "GuC log snapshot not allocated!\n");
196		return;
197	}
198
199	drm_printf(p, "GuC firmware: %s\n", snapshot->path);
200	drm_printf(p, "GuC version: %u.%u.%u (wanted %u.%u.%u)\n",
201		   snapshot->ver_found.major, snapshot->ver_found.minor, snapshot->ver_found.patch,
202		   snapshot->ver_want.major, snapshot->ver_want.minor, snapshot->ver_want.patch);
203	drm_printf(p, "Kernel timestamp: 0x%08llX [%llu]\n", snapshot->ktime, snapshot->ktime);
204	drm_printf(p, "GuC timestamp: 0x%08llX [%llu]\n", snapshot->stamp, snapshot->stamp);
205	drm_printf(p, "Log level: %u\n", snapshot->level);
206
207	drm_printf(p, "[LOG].length: 0x%zx\n", snapshot->size);
208	remain = snapshot->size;
209	for (i = 0; i < snapshot->num_chunks; i++) {
210		size_t size = min(GUC_LOG_CHUNK_SIZE, remain);
211		const char *prefix = i ? NULL : "[LOG].data";
212		char suffix = i == snapshot->num_chunks - 1 ? '\n' : 0;
213
214		xe_print_blob_ascii85(p, prefix, suffix, snapshot->copy[i], 0, size);
215		remain -= size;
216	}
217}
218
219/**
220 * xe_guc_log_print_dmesg - dump a copy of the GuC log to dmesg
221 * @log: GuC log structure
222 */
223void xe_guc_log_print_dmesg(struct xe_guc_log *log)
224{
225	struct xe_gt *gt = log_to_gt(log);
226	static int g_count;
227	struct drm_printer ip = xe_gt_info_printer(gt);
228	struct drm_printer lp = drm_line_printer(&ip, "Capture", ++g_count);
229
230	drm_printf(&lp, "Dumping GuC log for %ps...\n", __builtin_return_address(0));
231
232	xe_guc_log_print(log, &lp);
233
234	drm_printf(&lp, "Done.\n");
235}
236
237/**
238 * xe_guc_log_print - dump a copy of the GuC log to some useful location
239 * @log: GuC log structure
240 * @p: the printer object to output to
241 */
242void xe_guc_log_print(struct xe_guc_log *log, struct drm_printer *p)
243{
244	struct xe_guc_log_snapshot *snapshot;
245
246	drm_printf(p, "**** GuC Log ****\n");
247
248	snapshot = xe_guc_log_snapshot_capture(log, false);
249	drm_printf(p, "CS reference clock: %u\n", log_to_gt(log)->info.reference_clock);
250	xe_guc_log_snapshot_print(snapshot, p);
251	xe_guc_log_snapshot_free(snapshot);
252}
253
254int xe_guc_log_init(struct xe_guc_log *log)
255{
256	struct xe_device *xe = log_to_xe(log);
257	struct xe_tile *tile = gt_to_tile(log_to_gt(log));
258	struct xe_bo *bo;
259
260	bo = xe_managed_bo_create_pin_map(xe, tile, guc_log_size(),
261					  XE_BO_FLAG_SYSTEM |
262					  XE_BO_FLAG_GGTT |
263					  XE_BO_FLAG_GGTT_INVALIDATE |
264					  XE_BO_FLAG_PINNED_NORESTORE);
265	if (IS_ERR(bo))
266		return PTR_ERR(bo);
267
268	xe_map_memset(xe, &bo->vmap, 0, 0, guc_log_size());
269	log->bo = bo;
270	log->level = xe_modparam.guc_log_level;
271
272	return 0;
273}
274
275ALLOW_ERROR_INJECTION(xe_guc_log_init, ERRNO); /* See xe_pci_probe() */
276
277static u32 xe_guc_log_section_size_crash(struct xe_guc_log *log)
278{
279	return CRASH_BUFFER_SIZE;
280}
281
282static u32 xe_guc_log_section_size_debug(struct xe_guc_log *log)
283{
284	return DEBUG_BUFFER_SIZE;
285}
286
287/**
288 * xe_guc_log_section_size_capture - Get capture buffer size within log sections.
289 * @log: The log object.
290 *
291 * This function will return the capture buffer size within log sections.
292 *
293 * Return: capture buffer size.
294 */
295u32 xe_guc_log_section_size_capture(struct xe_guc_log *log)
296{
297	return CAPTURE_BUFFER_SIZE;
298}
299
300/**
301 * xe_guc_get_log_buffer_size - Get log buffer size for a type.
302 * @log: The log object.
303 * @type: The log buffer type
304 *
305 * Return: buffer size.
306 */
307u32 xe_guc_get_log_buffer_size(struct xe_guc_log *log, enum guc_log_buffer_type type)
308{
309	switch (type) {
310	case GUC_LOG_BUFFER_CRASH_DUMP:
311		return xe_guc_log_section_size_crash(log);
312	case GUC_LOG_BUFFER_DEBUG:
313		return xe_guc_log_section_size_debug(log);
314	case GUC_LOG_BUFFER_CAPTURE:
315		return xe_guc_log_section_size_capture(log);
316	}
317	return 0;
318}
319
320/**
321 * xe_guc_get_log_buffer_offset - Get offset in log buffer for a type.
322 * @log: The log object.
323 * @type: The log buffer type
324 *
325 * This function will return the offset in the log buffer for a type.
326 * Return: buffer offset.
327 */
328u32 xe_guc_get_log_buffer_offset(struct xe_guc_log *log, enum guc_log_buffer_type type)
329{
330	enum guc_log_buffer_type i;
331	u32 offset = PAGE_SIZE;/* for the log_buffer_states */
332
333	for (i = GUC_LOG_BUFFER_CRASH_DUMP; i < GUC_LOG_BUFFER_TYPE_MAX; ++i) {
334		if (i == type)
335			break;
336		offset += xe_guc_get_log_buffer_size(log, i);
337	}
338
339	return offset;
340}
341
342/**
343 * xe_guc_check_log_buf_overflow - Check if log buffer overflowed
344 * @log: The log object.
345 * @type: The log buffer type
346 * @full_cnt: The count of buffer full
347 *
348 * This function will check count of buffer full against previous, mismatch
349 * indicate overflowed.
350 * Update the sampled_overflow counter, if the 4 bit counter overflowed, add
351 * up 16 to correct the value.
352 *
353 * Return: True if overflowed.
354 */
355bool xe_guc_check_log_buf_overflow(struct xe_guc_log *log, enum guc_log_buffer_type type,
356				   unsigned int full_cnt)
357{
358	unsigned int prev_full_cnt = log->stats[type].sampled_overflow;
359	bool overflow = false;
360
361	if (full_cnt != prev_full_cnt) {
362		overflow = true;
363
364		log->stats[type].overflow = full_cnt;
365		log->stats[type].sampled_overflow += full_cnt - prev_full_cnt;
366
367		if (full_cnt < prev_full_cnt) {
368			/* buffer_full_cnt is a 4 bit counter */
369			log->stats[type].sampled_overflow += 16;
370		}
371		xe_gt_notice(log_to_gt(log), "log buffer overflow\n");
372	}
373
374	return overflow;
375}