1 // SPDX-License-Identifier: MIT
2 /*
3 * Copyright © 2023 Intel Corporation
4 */
5 #include "xe_drm_client.h"
6
7 #include <drm/drm_print.h>
8 #include <uapi/drm/xe_drm.h>
9 #include <linux/kernel.h>
10 #include <linux/slab.h>
11 #include <linux/types.h>
12
13 #include "xe_assert.h"
14 #include "xe_bo.h"
15 #include "xe_bo_types.h"
16 #include "xe_device_types.h"
17 #include "xe_exec_queue.h"
18 #include "xe_force_wake.h"
19 #include "xe_gt.h"
20 #include "xe_hw_engine.h"
21 #include "xe_pm.h"
22 #include "xe_trace.h"
23
24 /**
25 * DOC: DRM Client usage stats
26 *
27 * The drm/xe driver implements the DRM client usage stats specification as
28 * documented in :ref:`drm-client-usage-stats`.
29 *
30 * Example of the output showing the implemented key value pairs and entirety of
31 * the currently possible format options:
32 *
33 * ::
34 *
35 * pos: 0
36 * flags: 0100002
37 * mnt_id: 26
38 * ino: 685
39 * drm-driver: xe
40 * drm-client-id: 3
41 * drm-pdev: 0000:03:00.0
42 * drm-total-system: 0
43 * drm-shared-system: 0
44 * drm-active-system: 0
45 * drm-resident-system: 0
46 * drm-purgeable-system: 0
47 * drm-total-gtt: 192 KiB
48 * drm-shared-gtt: 0
49 * drm-active-gtt: 0
50 * drm-resident-gtt: 192 KiB
51 * drm-total-vram0: 23992 KiB
52 * drm-shared-vram0: 16 MiB
53 * drm-active-vram0: 0
54 * drm-resident-vram0: 23992 KiB
55 * drm-total-stolen: 0
56 * drm-shared-stolen: 0
57 * drm-active-stolen: 0
58 * drm-resident-stolen: 0
59 * drm-cycles-rcs: 28257900
60 * drm-total-cycles-rcs: 7655183225
61 * drm-cycles-bcs: 0
62 * drm-total-cycles-bcs: 7655183225
63 * drm-cycles-vcs: 0
64 * drm-total-cycles-vcs: 7655183225
65 * drm-engine-capacity-vcs: 2
66 * drm-cycles-vecs: 0
67 * drm-total-cycles-vecs: 7655183225
68 * drm-engine-capacity-vecs: 2
69 * drm-cycles-ccs: 0
70 * drm-total-cycles-ccs: 7655183225
71 * drm-engine-capacity-ccs: 4
72 *
73 * Possible `drm-cycles-` key names are: `rcs`, `ccs`, `bcs`, `vcs`, `vecs` and
74 * "other".
75 */
76
77 /**
78 * xe_drm_client_alloc() - Allocate drm client
79 * @void: No arg
80 *
81 * Allocate drm client struct to track client memory against
82 * same till client life. Call this API whenever new client
83 * has opened xe device.
84 *
85 * Return: pointer to client struct or NULL if can't allocate
86 */
xe_drm_client_alloc(void)87 struct xe_drm_client *xe_drm_client_alloc(void)
88 {
89 struct xe_drm_client *client;
90
91 client = kzalloc_obj(*client);
92 if (!client)
93 return NULL;
94
95 kref_init(&client->kref);
96
97 #ifdef CONFIG_PROC_FS
98 spin_lock_init(&client->bos_lock);
99 INIT_LIST_HEAD(&client->bos_list);
100 #endif
101 return client;
102 }
103
104 /**
105 * __xe_drm_client_free() - Free client struct
106 * @kref: The reference
107 *
108 * This frees client struct. Call this API when xe device is closed
109 * by drm client.
110 *
111 * Return: void
112 */
__xe_drm_client_free(struct kref * kref)113 void __xe_drm_client_free(struct kref *kref)
114 {
115 struct xe_drm_client *client =
116 container_of(kref, typeof(*client), kref);
117
118 kfree(client);
119 }
120
121 #ifdef CONFIG_PROC_FS
122 /**
123 * xe_drm_client_add_bo() - Add BO for tracking client mem usage
124 * @client: The drm client ptr
125 * @bo: The xe BO ptr
126 *
127 * Add all BO created by individual drm client by calling this function.
128 * This helps in tracking client memory usage.
129 *
130 * Return: void
131 */
xe_drm_client_add_bo(struct xe_drm_client * client,struct xe_bo * bo)132 void xe_drm_client_add_bo(struct xe_drm_client *client,
133 struct xe_bo *bo)
134 {
135 XE_WARN_ON(bo->client);
136 XE_WARN_ON(!list_empty(&bo->client_link));
137
138 bo->client = xe_drm_client_get(client);
139 spin_lock(&client->bos_lock);
140 list_add_tail(&bo->client_link, &client->bos_list);
141 spin_unlock(&client->bos_lock);
142 }
143
144 /**
145 * xe_drm_client_remove_bo() - Remove BO for tracking client mem usage
146 * @bo: The xe BO ptr
147 *
148 * Remove all BO removed by individual drm client by calling this function.
149 * This helps in tracking client memory usage.
150 *
151 * Return: void
152 */
xe_drm_client_remove_bo(struct xe_bo * bo)153 void xe_drm_client_remove_bo(struct xe_bo *bo)
154 {
155 struct xe_device *xe = ttm_to_xe_device(bo->ttm.bdev);
156 struct xe_drm_client *client = bo->client;
157
158 xe_assert(xe, !kref_read(&bo->ttm.base.refcount));
159
160 spin_lock(&client->bos_lock);
161 list_del_init(&bo->client_link);
162 spin_unlock(&client->bos_lock);
163
164 xe_drm_client_put(client);
165 }
166
bo_meminfo(struct xe_bo * bo,struct drm_memory_stats stats[TTM_NUM_MEM_TYPES])167 static void bo_meminfo(struct xe_bo *bo,
168 struct drm_memory_stats stats[TTM_NUM_MEM_TYPES])
169 {
170 u64 sz = xe_bo_size(bo);
171 u32 mem_type;
172
173 xe_bo_assert_held(bo);
174
175 /*
176 * The resource can be NULL if the BO has been purged, plus maybe some
177 * other cases. Either way there shouldn't be any memory to account for,
178 * or a current resource to account this against, so skip for now.
179 */
180 if (!bo->ttm.resource)
181 return;
182
183 mem_type = bo->ttm.resource->mem_type;
184
185 if (drm_gem_object_is_shared_for_memory_stats(&bo->ttm.base))
186 stats[mem_type].shared += sz;
187 else
188 stats[mem_type].private += sz;
189
190 if (xe_bo_has_pages(bo)) {
191 stats[mem_type].resident += sz;
192
193 if (!dma_resv_test_signaled(bo->ttm.base.resv,
194 DMA_RESV_USAGE_BOOKKEEP))
195 stats[mem_type].active += sz;
196 else if (mem_type == XE_PL_SYSTEM || xe_bo_madv_is_dontneed(bo))
197 stats[mem_type].purgeable += sz;
198 }
199 }
200
show_meminfo(struct drm_printer * p,struct drm_file * file)201 static void show_meminfo(struct drm_printer *p, struct drm_file *file)
202 {
203 struct drm_memory_stats stats[TTM_NUM_MEM_TYPES] = {};
204 struct xe_file *xef = file->driver_priv;
205 struct ttm_device *bdev = &xef->xe->ttm;
206 struct ttm_resource_manager *man;
207 struct xe_drm_client *client;
208 struct drm_gem_object *obj;
209 struct xe_bo *bo;
210 LLIST_HEAD(deferred);
211 unsigned int id;
212 u32 mem_type;
213
214 client = xef->client;
215
216 /* Public objects. */
217 spin_lock(&file->table_lock);
218 idr_for_each_entry(&file->object_idr, obj, id) {
219 struct xe_bo *bo = gem_to_xe_bo(obj);
220
221 if (dma_resv_trylock(bo->ttm.base.resv)) {
222 bo_meminfo(bo, stats);
223 xe_bo_unlock(bo);
224 } else {
225 xe_bo_get(bo);
226 spin_unlock(&file->table_lock);
227
228 xe_bo_lock(bo, false);
229 bo_meminfo(bo, stats);
230 xe_bo_unlock(bo);
231
232 xe_bo_put(bo);
233 spin_lock(&file->table_lock);
234 }
235 }
236 spin_unlock(&file->table_lock);
237
238 /* Internal objects. */
239 spin_lock(&client->bos_lock);
240 list_for_each_entry(bo, &client->bos_list, client_link) {
241 if (!kref_get_unless_zero(&bo->ttm.base.refcount))
242 continue;
243
244 if (dma_resv_trylock(bo->ttm.base.resv)) {
245 bo_meminfo(bo, stats);
246 xe_bo_unlock(bo);
247 } else {
248 spin_unlock(&client->bos_lock);
249
250 xe_bo_lock(bo, false);
251 bo_meminfo(bo, stats);
252 xe_bo_unlock(bo);
253
254 spin_lock(&client->bos_lock);
255 /* The bo ref will prevent this bo from being removed from the list */
256 xe_assert(xef->xe, !list_empty(&bo->client_link));
257 }
258
259 xe_bo_put_deferred(bo, &deferred);
260 }
261 spin_unlock(&client->bos_lock);
262
263 xe_bo_put_commit(&deferred);
264
265 for (mem_type = XE_PL_SYSTEM; mem_type < TTM_NUM_MEM_TYPES; ++mem_type) {
266 if (!xe_mem_type_to_name[mem_type])
267 continue;
268
269 man = ttm_manager_type(bdev, mem_type);
270
271 if (man) {
272 drm_print_memory_stats(p,
273 &stats[mem_type],
274 DRM_GEM_OBJECT_ACTIVE |
275 DRM_GEM_OBJECT_RESIDENT |
276 DRM_GEM_OBJECT_PURGEABLE,
277 xe_mem_type_to_name[mem_type]);
278 }
279 }
280 }
281
any_engine(struct xe_device * xe)282 static struct xe_hw_engine *any_engine(struct xe_device *xe)
283 {
284 struct xe_gt *gt;
285 unsigned long gt_id;
286
287 for_each_gt(gt, xe, gt_id) {
288 struct xe_hw_engine *hwe = xe_gt_any_hw_engine(gt);
289
290 if (hwe)
291 return hwe;
292 }
293
294 return NULL;
295 }
296
297 /*
298 * Pick any engine and grab its forcewake. On error phwe will be NULL and
299 * the returned forcewake reference will be invalid. Callers should check
300 * phwe against NULL.
301 */
force_wake_get_any_engine(struct xe_device * xe,struct xe_hw_engine ** phwe)302 static struct xe_force_wake_ref force_wake_get_any_engine(struct xe_device *xe,
303 struct xe_hw_engine **phwe)
304 {
305 enum xe_force_wake_domains domain;
306 struct xe_force_wake_ref fw_ref = {};
307 struct xe_hw_engine *hwe;
308
309 *phwe = NULL;
310
311 hwe = any_engine(xe);
312 if (!hwe)
313 return fw_ref; /* will be invalid */
314
315 domain = xe_hw_engine_to_fw_domain(hwe);
316
317 fw_ref = xe_force_wake_constructor(gt_to_fw(hwe->gt), domain);
318 if (xe_force_wake_ref_has_domain(fw_ref.domains, domain))
319 *phwe = hwe; /* valid forcewake */
320
321 return fw_ref;
322 }
323
show_run_ticks(struct drm_printer * p,struct drm_file * file)324 static void show_run_ticks(struct drm_printer *p, struct drm_file *file)
325 {
326 unsigned long class, i, gt_id, capacity[XE_ENGINE_CLASS_MAX] = { };
327 struct xe_file *xef = file->driver_priv;
328 struct xe_device *xe = xef->xe;
329 struct xe_gt *gt;
330 struct xe_hw_engine *hwe;
331 struct xe_exec_queue *q;
332 u64 gpu_timestamp;
333
334 /*
335 * RING_TIMESTAMP registers are inaccessible in VF mode.
336 * Without drm-total-cycles-*, other keys provide little value.
337 * Show all or none of the optional "run_ticks" keys in this case.
338 */
339 if (IS_SRIOV_VF(xe))
340 return;
341
342 /*
343 * Wait for any exec queue going away: their cycles will get updated on
344 * context switch out, so wait for that to happen
345 */
346 wait_var_event(&xef->exec_queue.pending_removal,
347 !atomic_read(&xef->exec_queue.pending_removal));
348
349 scoped_guard(xe_pm_runtime, xe) {
350 CLASS(xe_force_wake_release_only, fw_ref)(force_wake_get_any_engine(xe, &hwe));
351 if (!hwe)
352 return;
353
354 /* Accumulate all the exec queues from this client */
355 mutex_lock(&xef->exec_queue.lock);
356 xa_for_each(&xef->exec_queue.xa, i, q) {
357 xe_exec_queue_get(q);
358 mutex_unlock(&xef->exec_queue.lock);
359
360 xe_exec_queue_update_run_ticks(q);
361
362 mutex_lock(&xef->exec_queue.lock);
363 xe_exec_queue_put(q);
364 }
365 mutex_unlock(&xef->exec_queue.lock);
366
367 gpu_timestamp = xe_hw_engine_read_timestamp(hwe);
368 }
369
370 for (class = 0; class < XE_ENGINE_CLASS_MAX; class++) {
371 const char *class_name;
372
373 for_each_gt(gt, xe, gt_id)
374 capacity[class] += gt->user_engines.instances_per_class[class];
375
376 /*
377 * Engines may be fused off or not exposed to userspace. Don't
378 * return anything if this entire class is not available
379 */
380 if (!capacity[class])
381 continue;
382
383 class_name = xe_hw_engine_class_to_str(class);
384 drm_printf(p, "drm-cycles-%s:\t%llu\n",
385 class_name, xef->run_ticks[class]);
386 drm_printf(p, "drm-total-cycles-%s:\t%llu\n",
387 class_name, gpu_timestamp);
388
389 if (capacity[class] > 1)
390 drm_printf(p, "drm-engine-capacity-%s:\t%lu\n",
391 class_name, capacity[class]);
392 }
393 }
394
395 /**
396 * xe_drm_client_fdinfo() - Callback for fdinfo interface
397 * @p: The drm_printer ptr
398 * @file: The drm_file ptr
399 *
400 * This is callback for drm fdinfo interface. Register this callback
401 * in drm driver ops for show_fdinfo.
402 *
403 * Return: void
404 */
xe_drm_client_fdinfo(struct drm_printer * p,struct drm_file * file)405 void xe_drm_client_fdinfo(struct drm_printer *p, struct drm_file *file)
406 {
407 show_meminfo(p, file);
408 show_run_ticks(p, file);
409 }
410 #endif
411