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 <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 */ 87 struct xe_drm_client *xe_drm_client_alloc(void) 88 { 89 struct xe_drm_client *client; 90 91 client = kzalloc(sizeof(*client), GFP_KERNEL); 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 */ 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 */ 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 spin_lock(&client->bos_lock); 139 bo->client = xe_drm_client_get(client); 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 */ 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 167 static void bo_meminfo(struct xe_bo *bo, 168 struct drm_memory_stats stats[TTM_NUM_MEM_TYPES]) 169 { 170 u64 sz = bo->size; 171 u32 mem_type; 172 173 xe_bo_assert_held(bo); 174 175 if (bo->placement.placement) 176 mem_type = bo->placement.placement->mem_type; 177 else 178 mem_type = XE_PL_TT; 179 180 if (drm_gem_object_is_shared_for_memory_stats(&bo->ttm.base)) 181 stats[mem_type].shared += sz; 182 else 183 stats[mem_type].private += sz; 184 185 if (xe_bo_has_pages(bo)) { 186 stats[mem_type].resident += sz; 187 188 if (!dma_resv_test_signaled(bo->ttm.base.resv, 189 DMA_RESV_USAGE_BOOKKEEP)) 190 stats[mem_type].active += sz; 191 else if (mem_type == XE_PL_SYSTEM) 192 stats[mem_type].purgeable += sz; 193 } 194 } 195 196 static void show_meminfo(struct drm_printer *p, struct drm_file *file) 197 { 198 struct drm_memory_stats stats[TTM_NUM_MEM_TYPES] = {}; 199 struct xe_file *xef = file->driver_priv; 200 struct ttm_device *bdev = &xef->xe->ttm; 201 struct ttm_resource_manager *man; 202 struct xe_drm_client *client; 203 struct drm_gem_object *obj; 204 struct xe_bo *bo; 205 LLIST_HEAD(deferred); 206 unsigned int id; 207 u32 mem_type; 208 209 client = xef->client; 210 211 /* Public objects. */ 212 spin_lock(&file->table_lock); 213 idr_for_each_entry(&file->object_idr, obj, id) { 214 struct xe_bo *bo = gem_to_xe_bo(obj); 215 216 if (dma_resv_trylock(bo->ttm.base.resv)) { 217 bo_meminfo(bo, stats); 218 xe_bo_unlock(bo); 219 } else { 220 xe_bo_get(bo); 221 spin_unlock(&file->table_lock); 222 223 xe_bo_lock(bo, false); 224 bo_meminfo(bo, stats); 225 xe_bo_unlock(bo); 226 227 xe_bo_put(bo); 228 spin_lock(&file->table_lock); 229 } 230 } 231 spin_unlock(&file->table_lock); 232 233 /* Internal objects. */ 234 spin_lock(&client->bos_lock); 235 list_for_each_entry(bo, &client->bos_list, client_link) { 236 if (!kref_get_unless_zero(&bo->ttm.base.refcount)) 237 continue; 238 239 if (dma_resv_trylock(bo->ttm.base.resv)) { 240 bo_meminfo(bo, stats); 241 xe_bo_unlock(bo); 242 } else { 243 spin_unlock(&client->bos_lock); 244 245 xe_bo_lock(bo, false); 246 bo_meminfo(bo, stats); 247 xe_bo_unlock(bo); 248 249 spin_lock(&client->bos_lock); 250 /* The bo ref will prevent this bo from being removed from the list */ 251 xe_assert(xef->xe, !list_empty(&bo->client_link)); 252 } 253 254 xe_bo_put_deferred(bo, &deferred); 255 } 256 spin_unlock(&client->bos_lock); 257 258 xe_bo_put_commit(&deferred); 259 260 for (mem_type = XE_PL_SYSTEM; mem_type < TTM_NUM_MEM_TYPES; ++mem_type) { 261 if (!xe_mem_type_to_name[mem_type]) 262 continue; 263 264 man = ttm_manager_type(bdev, mem_type); 265 266 if (man) { 267 drm_print_memory_stats(p, 268 &stats[mem_type], 269 DRM_GEM_OBJECT_RESIDENT | 270 (mem_type != XE_PL_SYSTEM ? 0 : 271 DRM_GEM_OBJECT_PURGEABLE), 272 xe_mem_type_to_name[mem_type]); 273 } 274 } 275 } 276 277 static void show_run_ticks(struct drm_printer *p, struct drm_file *file) 278 { 279 unsigned long class, i, gt_id, capacity[XE_ENGINE_CLASS_MAX] = { }; 280 struct xe_file *xef = file->driver_priv; 281 struct xe_device *xe = xef->xe; 282 struct xe_gt *gt; 283 struct xe_hw_engine *hwe; 284 struct xe_exec_queue *q; 285 u64 gpu_timestamp; 286 287 xe_pm_runtime_get(xe); 288 289 /* Accumulate all the exec queues from this client */ 290 mutex_lock(&xef->exec_queue.lock); 291 xa_for_each(&xef->exec_queue.xa, i, q) 292 xe_exec_queue_update_run_ticks(q); 293 mutex_unlock(&xef->exec_queue.lock); 294 295 /* Get the total GPU cycles */ 296 for_each_gt(gt, xe, gt_id) { 297 enum xe_force_wake_domains fw; 298 299 hwe = xe_gt_any_hw_engine(gt); 300 if (!hwe) 301 continue; 302 303 fw = xe_hw_engine_to_fw_domain(hwe); 304 if (xe_force_wake_get(gt_to_fw(gt), fw)) { 305 hwe = NULL; 306 break; 307 } 308 309 gpu_timestamp = xe_hw_engine_read_timestamp(hwe); 310 XE_WARN_ON(xe_force_wake_put(gt_to_fw(gt), fw)); 311 break; 312 } 313 314 xe_pm_runtime_put(xe); 315 316 if (unlikely(!hwe)) 317 return; 318 319 for (class = 0; class < XE_ENGINE_CLASS_MAX; class++) { 320 const char *class_name; 321 322 for_each_gt(gt, xe, gt_id) 323 capacity[class] += gt->user_engines.instances_per_class[class]; 324 325 /* 326 * Engines may be fused off or not exposed to userspace. Don't 327 * return anything if this entire class is not available 328 */ 329 if (!capacity[class]) 330 continue; 331 332 class_name = xe_hw_engine_class_to_str(class); 333 drm_printf(p, "drm-cycles-%s:\t%llu\n", 334 class_name, xef->run_ticks[class]); 335 drm_printf(p, "drm-total-cycles-%s:\t%llu\n", 336 class_name, gpu_timestamp); 337 338 if (capacity[class] > 1) 339 drm_printf(p, "drm-engine-capacity-%s:\t%lu\n", 340 class_name, capacity[class]); 341 } 342 } 343 344 /** 345 * xe_drm_client_fdinfo() - Callback for fdinfo interface 346 * @p: The drm_printer ptr 347 * @file: The drm_file ptr 348 * 349 * This is callabck for drm fdinfo interface. Register this callback 350 * in drm driver ops for show_fdinfo. 351 * 352 * Return: void 353 */ 354 void xe_drm_client_fdinfo(struct drm_printer *p, struct drm_file *file) 355 { 356 show_meminfo(p, file); 357 show_run_ticks(p, file); 358 } 359 #endif 360