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 
22 static struct xe_guc *
log_to_guc(struct xe_guc_log * log)23 log_to_guc(struct xe_guc_log *log)
24 {
25 	return container_of(log, struct xe_guc, log);
26 }
27 
28 static struct xe_gt *
log_to_gt(struct xe_guc_log * log)29 log_to_gt(struct xe_guc_log *log)
30 {
31 	return container_of(log, struct xe_gt, uc.guc.log);
32 }
33 
34 static struct xe_device *
log_to_xe(struct xe_guc_log * log)35 log_to_xe(struct xe_guc_log *log)
36 {
37 	return gt_to_xe(log_to_gt(log));
38 }
39 
guc_log_size(void)40 static 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 
xe_guc_log_snapshot_alloc(struct xe_guc_log * log,bool atomic)67 static 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 = log->bo->size;
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 
102 fail_copy:
103 	for (i = 0; i < snapshot->num_chunks; i++)
104 		kfree(snapshot->copy[i]);
105 	kfree(snapshot->copy);
106 fail_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  */
xe_guc_log_snapshot_free(struct xe_guc_log_snapshot * snapshot)118 void 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  */
xe_guc_log_snapshot_capture(struct xe_guc_log * log,bool atomic)142 struct 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  */
xe_guc_log_snapshot_print(struct xe_guc_log_snapshot * snapshot,struct drm_printer * p)189 void 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  */
xe_guc_log_print_dmesg(struct xe_guc_log * log)223 void 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  */
xe_guc_log_print(struct xe_guc_log * log,struct drm_printer * p)242 void 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 
xe_guc_log_init(struct xe_guc_log * log)254 int 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 	if (IS_ERR(bo))
265 		return PTR_ERR(bo);
266 
267 	xe_map_memset(xe, &bo->vmap, 0, 0, guc_log_size());
268 	log->bo = bo;
269 	log->level = xe_modparam.guc_log_level;
270 
271 	return 0;
272 }
273 
274 ALLOW_ERROR_INJECTION(xe_guc_log_init, ERRNO); /* See xe_pci_probe() */
275 
xe_guc_log_section_size_crash(struct xe_guc_log * log)276 static u32 xe_guc_log_section_size_crash(struct xe_guc_log *log)
277 {
278 	return CRASH_BUFFER_SIZE;
279 }
280 
xe_guc_log_section_size_debug(struct xe_guc_log * log)281 static u32 xe_guc_log_section_size_debug(struct xe_guc_log *log)
282 {
283 	return DEBUG_BUFFER_SIZE;
284 }
285 
286 /**
287  * xe_guc_log_section_size_capture - Get capture buffer size within log sections.
288  * @log: The log object.
289  *
290  * This function will return the capture buffer size within log sections.
291  *
292  * Return: capture buffer size.
293  */
xe_guc_log_section_size_capture(struct xe_guc_log * log)294 u32 xe_guc_log_section_size_capture(struct xe_guc_log *log)
295 {
296 	return CAPTURE_BUFFER_SIZE;
297 }
298 
299 /**
300  * xe_guc_get_log_buffer_size - Get log buffer size for a type.
301  * @log: The log object.
302  * @type: The log buffer type
303  *
304  * Return: buffer size.
305  */
xe_guc_get_log_buffer_size(struct xe_guc_log * log,enum guc_log_buffer_type type)306 u32 xe_guc_get_log_buffer_size(struct xe_guc_log *log, enum guc_log_buffer_type type)
307 {
308 	switch (type) {
309 	case GUC_LOG_BUFFER_CRASH_DUMP:
310 		return xe_guc_log_section_size_crash(log);
311 	case GUC_LOG_BUFFER_DEBUG:
312 		return xe_guc_log_section_size_debug(log);
313 	case GUC_LOG_BUFFER_CAPTURE:
314 		return xe_guc_log_section_size_capture(log);
315 	}
316 	return 0;
317 }
318 
319 /**
320  * xe_guc_get_log_buffer_offset - Get offset in log buffer for a type.
321  * @log: The log object.
322  * @type: The log buffer type
323  *
324  * This function will return the offset in the log buffer for a type.
325  * Return: buffer offset.
326  */
xe_guc_get_log_buffer_offset(struct xe_guc_log * log,enum guc_log_buffer_type type)327 u32 xe_guc_get_log_buffer_offset(struct xe_guc_log *log, enum guc_log_buffer_type type)
328 {
329 	enum guc_log_buffer_type i;
330 	u32 offset = PAGE_SIZE;/* for the log_buffer_states */
331 
332 	for (i = GUC_LOG_BUFFER_CRASH_DUMP; i < GUC_LOG_BUFFER_TYPE_MAX; ++i) {
333 		if (i == type)
334 			break;
335 		offset += xe_guc_get_log_buffer_size(log, i);
336 	}
337 
338 	return offset;
339 }
340 
341 /**
342  * xe_guc_check_log_buf_overflow - Check if log buffer overflowed
343  * @log: The log object.
344  * @type: The log buffer type
345  * @full_cnt: The count of buffer full
346  *
347  * This function will check count of buffer full against previous, mismatch
348  * indicate overflowed.
349  * Update the sampled_overflow counter, if the 4 bit counter overflowed, add
350  * up 16 to correct the value.
351  *
352  * Return: True if overflowed.
353  */
xe_guc_check_log_buf_overflow(struct xe_guc_log * log,enum guc_log_buffer_type type,unsigned int full_cnt)354 bool xe_guc_check_log_buf_overflow(struct xe_guc_log *log, enum guc_log_buffer_type type,
355 				   unsigned int full_cnt)
356 {
357 	unsigned int prev_full_cnt = log->stats[type].sampled_overflow;
358 	bool overflow = false;
359 
360 	if (full_cnt != prev_full_cnt) {
361 		overflow = true;
362 
363 		log->stats[type].overflow = full_cnt;
364 		log->stats[type].sampled_overflow += full_cnt - prev_full_cnt;
365 
366 		if (full_cnt < prev_full_cnt) {
367 			/* buffer_full_cnt is a 4 bit counter */
368 			log->stats[type].sampled_overflow += 16;
369 		}
370 		xe_gt_notice(log_to_gt(log), "log buffer overflow\n");
371 	}
372 
373 	return overflow;
374 }
375