1 /* 2 * Created: Sun Dec 21 13:08:50 2008 by bgamari@gmail.com 3 * 4 * Copyright 2008 Ben Gamari <bgamari@gmail.com> 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice (including the next 14 * paragraph) shall be included in all copies or substantial portions of the 15 * Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26 #include <linux/debugfs.h> 27 #include <linux/export.h> 28 #include <linux/seq_file.h> 29 #include <linux/slab.h> 30 #include <linux/uaccess.h> 31 32 #include <drm/drm_atomic.h> 33 #include <drm/drm_auth.h> 34 #include <drm/drm_bridge.h> 35 #include <drm/drm_client.h> 36 #include <drm/drm_debugfs.h> 37 #include <drm/drm_device.h> 38 #include <drm/drm_drv.h> 39 #include <drm/drm_edid.h> 40 #include <drm/drm_file.h> 41 #include <drm/drm_gem.h> 42 #include <drm/drm_managed.h> 43 #include <drm/drm_gpuva_mgr.h> 44 45 #include "drm_crtc_internal.h" 46 #include "drm_internal.h" 47 48 #if defined(CONFIG_DEBUG_FS) 49 50 /*************************************************** 51 * Initialization, etc. 52 **************************************************/ 53 54 static int drm_name_info(struct seq_file *m, void *data) 55 { 56 struct drm_debugfs_entry *entry = m->private; 57 struct drm_device *dev = entry->dev; 58 struct drm_master *master; 59 60 mutex_lock(&dev->master_mutex); 61 master = dev->master; 62 seq_printf(m, "%s", dev->driver->name); 63 if (dev->dev) 64 seq_printf(m, " dev=%s", dev_name(dev->dev)); 65 if (master && master->unique) 66 seq_printf(m, " master=%s", master->unique); 67 if (dev->unique) 68 seq_printf(m, " unique=%s", dev->unique); 69 seq_printf(m, "\n"); 70 mutex_unlock(&dev->master_mutex); 71 72 return 0; 73 } 74 75 static int drm_clients_info(struct seq_file *m, void *data) 76 { 77 struct drm_debugfs_entry *entry = m->private; 78 struct drm_device *dev = entry->dev; 79 struct drm_file *priv; 80 kuid_t uid; 81 82 seq_printf(m, 83 "%20s %5s %3s master a %5s %10s\n", 84 "command", 85 "tgid", 86 "dev", 87 "uid", 88 "magic"); 89 90 /* dev->filelist is sorted youngest first, but we want to present 91 * oldest first (i.e. kernel, servers, clients), so walk backwardss. 92 */ 93 mutex_lock(&dev->filelist_mutex); 94 list_for_each_entry_reverse(priv, &dev->filelist, lhead) { 95 struct task_struct *task; 96 bool is_current_master = drm_is_current_master(priv); 97 98 rcu_read_lock(); /* locks pid_task()->comm */ 99 task = pid_task(priv->pid, PIDTYPE_TGID); 100 uid = task ? __task_cred(task)->euid : GLOBAL_ROOT_UID; 101 seq_printf(m, "%20s %5d %3d %c %c %5d %10u\n", 102 task ? task->comm : "<unknown>", 103 pid_vnr(priv->pid), 104 priv->minor->index, 105 is_current_master ? 'y' : 'n', 106 priv->authenticated ? 'y' : 'n', 107 from_kuid_munged(seq_user_ns(m), uid), 108 priv->magic); 109 rcu_read_unlock(); 110 } 111 mutex_unlock(&dev->filelist_mutex); 112 return 0; 113 } 114 115 static int drm_gem_one_name_info(int id, void *ptr, void *data) 116 { 117 struct drm_gem_object *obj = ptr; 118 struct seq_file *m = data; 119 120 seq_printf(m, "%6d %8zd %7d %8d\n", 121 obj->name, obj->size, 122 obj->handle_count, 123 kref_read(&obj->refcount)); 124 return 0; 125 } 126 127 static int drm_gem_name_info(struct seq_file *m, void *data) 128 { 129 struct drm_debugfs_entry *entry = m->private; 130 struct drm_device *dev = entry->dev; 131 132 seq_printf(m, " name size handles refcount\n"); 133 134 mutex_lock(&dev->object_name_lock); 135 idr_for_each(&dev->object_name_idr, drm_gem_one_name_info, m); 136 mutex_unlock(&dev->object_name_lock); 137 138 return 0; 139 } 140 141 static const struct drm_debugfs_info drm_debugfs_list[] = { 142 {"name", drm_name_info, 0}, 143 {"clients", drm_clients_info, 0}, 144 {"gem_names", drm_gem_name_info, DRIVER_GEM}, 145 }; 146 #define DRM_DEBUGFS_ENTRIES ARRAY_SIZE(drm_debugfs_list) 147 148 149 static int drm_debugfs_open(struct inode *inode, struct file *file) 150 { 151 struct drm_info_node *node = inode->i_private; 152 153 return single_open(file, node->info_ent->show, node); 154 } 155 156 static int drm_debugfs_entry_open(struct inode *inode, struct file *file) 157 { 158 struct drm_debugfs_entry *entry = inode->i_private; 159 struct drm_debugfs_info *node = &entry->file; 160 161 return single_open(file, node->show, entry); 162 } 163 164 static const struct file_operations drm_debugfs_entry_fops = { 165 .owner = THIS_MODULE, 166 .open = drm_debugfs_entry_open, 167 .read = seq_read, 168 .llseek = seq_lseek, 169 .release = single_release, 170 }; 171 172 static const struct file_operations drm_debugfs_fops = { 173 .owner = THIS_MODULE, 174 .open = drm_debugfs_open, 175 .read = seq_read, 176 .llseek = seq_lseek, 177 .release = single_release, 178 }; 179 180 /** 181 * drm_debugfs_gpuva_info - dump the given DRM GPU VA space 182 * @m: pointer to the &seq_file to write 183 * @mgr: the &drm_gpuva_manager representing the GPU VA space 184 * 185 * Dumps the GPU VA mappings of a given DRM GPU VA manager. 186 * 187 * For each DRM GPU VA space drivers should call this function from their 188 * &drm_info_list's show callback. 189 * 190 * Returns: 0 on success, -ENODEV if the &mgr is not initialized 191 */ 192 int drm_debugfs_gpuva_info(struct seq_file *m, 193 struct drm_gpuva_manager *mgr) 194 { 195 struct drm_gpuva *va, *kva = &mgr->kernel_alloc_node; 196 197 if (!mgr->name) 198 return -ENODEV; 199 200 seq_printf(m, "DRM GPU VA space (%s) [0x%016llx;0x%016llx]\n", 201 mgr->name, mgr->mm_start, mgr->mm_start + mgr->mm_range); 202 seq_printf(m, "Kernel reserved node [0x%016llx;0x%016llx]\n", 203 kva->va.addr, kva->va.addr + kva->va.range); 204 seq_puts(m, "\n"); 205 seq_puts(m, " VAs | start | range | end | object | object offset\n"); 206 seq_puts(m, "-------------------------------------------------------------------------------------------------------------\n"); 207 drm_gpuva_for_each_va(va, mgr) { 208 if (unlikely(va == kva)) 209 continue; 210 211 seq_printf(m, " | 0x%016llx | 0x%016llx | 0x%016llx | 0x%016llx | 0x%016llx\n", 212 va->va.addr, va->va.range, va->va.addr + va->va.range, 213 (u64)(uintptr_t)va->gem.obj, va->gem.offset); 214 } 215 216 return 0; 217 } 218 EXPORT_SYMBOL(drm_debugfs_gpuva_info); 219 220 /** 221 * drm_debugfs_create_files - Initialize a given set of debugfs files for DRM 222 * minor 223 * @files: The array of files to create 224 * @count: The number of files given 225 * @root: DRI debugfs dir entry. 226 * @minor: device minor number 227 * 228 * Create a given set of debugfs files represented by an array of 229 * &struct drm_info_list in the given root directory. These files will be removed 230 * automatically on drm_debugfs_cleanup(). 231 */ 232 void drm_debugfs_create_files(const struct drm_info_list *files, int count, 233 struct dentry *root, struct drm_minor *minor) 234 { 235 struct drm_device *dev = minor->dev; 236 struct drm_info_node *tmp; 237 int i; 238 239 for (i = 0; i < count; i++) { 240 u32 features = files[i].driver_features; 241 242 if (features && !drm_core_check_all_features(dev, features)) 243 continue; 244 245 tmp = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL); 246 if (tmp == NULL) 247 continue; 248 249 tmp->minor = minor; 250 tmp->dent = debugfs_create_file(files[i].name, 251 0444, root, tmp, 252 &drm_debugfs_fops); 253 tmp->info_ent = &files[i]; 254 255 mutex_lock(&minor->debugfs_lock); 256 list_add(&tmp->list, &minor->debugfs_list); 257 mutex_unlock(&minor->debugfs_lock); 258 } 259 } 260 EXPORT_SYMBOL(drm_debugfs_create_files); 261 262 int drm_debugfs_init(struct drm_minor *minor, int minor_id, 263 struct dentry *root) 264 { 265 struct drm_device *dev = minor->dev; 266 struct drm_debugfs_entry *entry, *tmp; 267 char name[64]; 268 269 INIT_LIST_HEAD(&minor->debugfs_list); 270 mutex_init(&minor->debugfs_lock); 271 sprintf(name, "%d", minor_id); 272 minor->debugfs_root = debugfs_create_dir(name, root); 273 274 drm_debugfs_add_files(minor->dev, drm_debugfs_list, DRM_DEBUGFS_ENTRIES); 275 276 if (drm_drv_uses_atomic_modeset(dev)) { 277 drm_atomic_debugfs_init(minor); 278 drm_bridge_debugfs_init(minor); 279 } 280 281 if (drm_core_check_feature(dev, DRIVER_MODESET)) { 282 drm_framebuffer_debugfs_init(minor); 283 284 drm_client_debugfs_init(minor); 285 } 286 287 if (dev->driver->debugfs_init) 288 dev->driver->debugfs_init(minor); 289 290 list_for_each_entry_safe(entry, tmp, &dev->debugfs_list, list) { 291 debugfs_create_file(entry->file.name, 0444, 292 minor->debugfs_root, entry, &drm_debugfs_entry_fops); 293 list_del(&entry->list); 294 } 295 296 return 0; 297 } 298 299 void drm_debugfs_late_register(struct drm_device *dev) 300 { 301 struct drm_minor *minor = dev->primary; 302 struct drm_debugfs_entry *entry, *tmp; 303 304 if (!minor) 305 return; 306 307 list_for_each_entry_safe(entry, tmp, &dev->debugfs_list, list) { 308 debugfs_create_file(entry->file.name, 0444, 309 minor->debugfs_root, entry, &drm_debugfs_entry_fops); 310 list_del(&entry->list); 311 } 312 } 313 314 int drm_debugfs_remove_files(const struct drm_info_list *files, int count, 315 struct drm_minor *minor) 316 { 317 struct list_head *pos, *q; 318 struct drm_info_node *tmp; 319 int i; 320 321 mutex_lock(&minor->debugfs_lock); 322 for (i = 0; i < count; i++) { 323 list_for_each_safe(pos, q, &minor->debugfs_list) { 324 tmp = list_entry(pos, struct drm_info_node, list); 325 if (tmp->info_ent == &files[i]) { 326 debugfs_remove(tmp->dent); 327 list_del(pos); 328 kfree(tmp); 329 } 330 } 331 } 332 mutex_unlock(&minor->debugfs_lock); 333 return 0; 334 } 335 EXPORT_SYMBOL(drm_debugfs_remove_files); 336 337 static void drm_debugfs_remove_all_files(struct drm_minor *minor) 338 { 339 struct drm_info_node *node, *tmp; 340 341 mutex_lock(&minor->debugfs_lock); 342 list_for_each_entry_safe(node, tmp, &minor->debugfs_list, list) { 343 debugfs_remove(node->dent); 344 list_del(&node->list); 345 kfree(node); 346 } 347 mutex_unlock(&minor->debugfs_lock); 348 } 349 350 void drm_debugfs_cleanup(struct drm_minor *minor) 351 { 352 if (!minor->debugfs_root) 353 return; 354 355 drm_debugfs_remove_all_files(minor); 356 357 debugfs_remove_recursive(minor->debugfs_root); 358 minor->debugfs_root = NULL; 359 } 360 361 /** 362 * drm_debugfs_add_file - Add a given file to the DRM device debugfs file list 363 * @dev: drm device for the ioctl 364 * @name: debugfs file name 365 * @show: show callback 366 * @data: driver-private data, should not be device-specific 367 * 368 * Add a given file entry to the DRM device debugfs file list to be created on 369 * drm_debugfs_init. 370 */ 371 void drm_debugfs_add_file(struct drm_device *dev, const char *name, 372 int (*show)(struct seq_file*, void*), void *data) 373 { 374 struct drm_debugfs_entry *entry = drmm_kzalloc(dev, sizeof(*entry), GFP_KERNEL); 375 376 if (!entry) 377 return; 378 379 entry->file.name = name; 380 entry->file.show = show; 381 entry->file.data = data; 382 entry->dev = dev; 383 384 mutex_lock(&dev->debugfs_mutex); 385 list_add(&entry->list, &dev->debugfs_list); 386 mutex_unlock(&dev->debugfs_mutex); 387 } 388 EXPORT_SYMBOL(drm_debugfs_add_file); 389 390 /** 391 * drm_debugfs_add_files - Add an array of files to the DRM device debugfs file list 392 * @dev: drm device for the ioctl 393 * @files: The array of files to create 394 * @count: The number of files given 395 * 396 * Add a given set of debugfs files represented by an array of 397 * &struct drm_debugfs_info in the DRM device debugfs file list. 398 */ 399 void drm_debugfs_add_files(struct drm_device *dev, const struct drm_debugfs_info *files, int count) 400 { 401 int i; 402 403 for (i = 0; i < count; i++) 404 drm_debugfs_add_file(dev, files[i].name, files[i].show, files[i].data); 405 } 406 EXPORT_SYMBOL(drm_debugfs_add_files); 407 408 static int connector_show(struct seq_file *m, void *data) 409 { 410 struct drm_connector *connector = m->private; 411 412 seq_printf(m, "%s\n", drm_get_connector_force_name(connector->force)); 413 414 return 0; 415 } 416 417 static int connector_open(struct inode *inode, struct file *file) 418 { 419 struct drm_connector *dev = inode->i_private; 420 421 return single_open(file, connector_show, dev); 422 } 423 424 static ssize_t connector_write(struct file *file, const char __user *ubuf, 425 size_t len, loff_t *offp) 426 { 427 struct seq_file *m = file->private_data; 428 struct drm_connector *connector = m->private; 429 char buf[12]; 430 431 if (len > sizeof(buf) - 1) 432 return -EINVAL; 433 434 if (copy_from_user(buf, ubuf, len)) 435 return -EFAULT; 436 437 buf[len] = '\0'; 438 439 if (sysfs_streq(buf, "on")) 440 connector->force = DRM_FORCE_ON; 441 else if (sysfs_streq(buf, "digital")) 442 connector->force = DRM_FORCE_ON_DIGITAL; 443 else if (sysfs_streq(buf, "off")) 444 connector->force = DRM_FORCE_OFF; 445 else if (sysfs_streq(buf, "unspecified")) 446 connector->force = DRM_FORCE_UNSPECIFIED; 447 else 448 return -EINVAL; 449 450 return len; 451 } 452 453 static int edid_show(struct seq_file *m, void *data) 454 { 455 return drm_edid_override_show(m->private, m); 456 } 457 458 static int edid_open(struct inode *inode, struct file *file) 459 { 460 struct drm_connector *dev = inode->i_private; 461 462 return single_open(file, edid_show, dev); 463 } 464 465 static ssize_t edid_write(struct file *file, const char __user *ubuf, 466 size_t len, loff_t *offp) 467 { 468 struct seq_file *m = file->private_data; 469 struct drm_connector *connector = m->private; 470 char *buf; 471 int ret; 472 473 buf = memdup_user(ubuf, len); 474 if (IS_ERR(buf)) 475 return PTR_ERR(buf); 476 477 if (len == 5 && !strncmp(buf, "reset", 5)) 478 ret = drm_edid_override_reset(connector); 479 else 480 ret = drm_edid_override_set(connector, buf, len); 481 482 kfree(buf); 483 484 return ret ? ret : len; 485 } 486 487 /* 488 * Returns the min and max vrr vfreq through the connector's debugfs file. 489 * Example usage: cat /sys/kernel/debug/dri/0/DP-1/vrr_range 490 */ 491 static int vrr_range_show(struct seq_file *m, void *data) 492 { 493 struct drm_connector *connector = m->private; 494 495 if (connector->status != connector_status_connected) 496 return -ENODEV; 497 498 seq_printf(m, "Min: %u\n", connector->display_info.monitor_range.min_vfreq); 499 seq_printf(m, "Max: %u\n", connector->display_info.monitor_range.max_vfreq); 500 501 return 0; 502 } 503 DEFINE_SHOW_ATTRIBUTE(vrr_range); 504 505 /* 506 * Returns Connector's max supported bpc through debugfs file. 507 * Example usage: cat /sys/kernel/debug/dri/0/DP-1/output_bpc 508 */ 509 static int output_bpc_show(struct seq_file *m, void *data) 510 { 511 struct drm_connector *connector = m->private; 512 513 if (connector->status != connector_status_connected) 514 return -ENODEV; 515 516 seq_printf(m, "Maximum: %u\n", connector->display_info.bpc); 517 518 return 0; 519 } 520 DEFINE_SHOW_ATTRIBUTE(output_bpc); 521 522 static const struct file_operations drm_edid_fops = { 523 .owner = THIS_MODULE, 524 .open = edid_open, 525 .read = seq_read, 526 .llseek = seq_lseek, 527 .release = single_release, 528 .write = edid_write 529 }; 530 531 532 static const struct file_operations drm_connector_fops = { 533 .owner = THIS_MODULE, 534 .open = connector_open, 535 .read = seq_read, 536 .llseek = seq_lseek, 537 .release = single_release, 538 .write = connector_write 539 }; 540 541 void drm_debugfs_connector_add(struct drm_connector *connector) 542 { 543 struct drm_minor *minor = connector->dev->primary; 544 struct dentry *root; 545 546 if (!minor->debugfs_root) 547 return; 548 549 root = debugfs_create_dir(connector->name, minor->debugfs_root); 550 connector->debugfs_entry = root; 551 552 /* force */ 553 debugfs_create_file("force", 0644, root, connector, 554 &drm_connector_fops); 555 556 /* edid */ 557 debugfs_create_file("edid_override", 0644, root, connector, 558 &drm_edid_fops); 559 560 /* vrr range */ 561 debugfs_create_file("vrr_range", 0444, root, connector, 562 &vrr_range_fops); 563 564 /* max bpc */ 565 debugfs_create_file("output_bpc", 0444, root, connector, 566 &output_bpc_fops); 567 568 if (connector->funcs->debugfs_init) 569 connector->funcs->debugfs_init(connector, root); 570 } 571 572 void drm_debugfs_connector_remove(struct drm_connector *connector) 573 { 574 if (!connector->debugfs_entry) 575 return; 576 577 debugfs_remove_recursive(connector->debugfs_entry); 578 579 connector->debugfs_entry = NULL; 580 } 581 582 void drm_debugfs_crtc_add(struct drm_crtc *crtc) 583 { 584 struct drm_minor *minor = crtc->dev->primary; 585 struct dentry *root; 586 char *name; 587 588 name = kasprintf(GFP_KERNEL, "crtc-%d", crtc->index); 589 if (!name) 590 return; 591 592 root = debugfs_create_dir(name, minor->debugfs_root); 593 kfree(name); 594 595 crtc->debugfs_entry = root; 596 597 drm_debugfs_crtc_crc_add(crtc); 598 } 599 600 void drm_debugfs_crtc_remove(struct drm_crtc *crtc) 601 { 602 debugfs_remove_recursive(crtc->debugfs_entry); 603 crtc->debugfs_entry = NULL; 604 } 605 606 #endif /* CONFIG_DEBUG_FS */ 607