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_gpuvm.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 bool is_current_master = drm_is_current_master(priv); 96 struct task_struct *task; 97 struct pid *pid; 98 99 rcu_read_lock(); /* Locks priv->pid and pid_task()->comm! */ 100 pid = rcu_dereference(priv->pid); 101 task = pid_task(pid, PIDTYPE_TGID); 102 uid = task ? __task_cred(task)->euid : GLOBAL_ROOT_UID; 103 seq_printf(m, "%20s %5d %3d %c %c %5d %10u\n", 104 task ? task->comm : "<unknown>", 105 pid_vnr(pid), 106 priv->minor->index, 107 is_current_master ? 'y' : 'n', 108 priv->authenticated ? 'y' : 'n', 109 from_kuid_munged(seq_user_ns(m), uid), 110 priv->magic); 111 rcu_read_unlock(); 112 } 113 mutex_unlock(&dev->filelist_mutex); 114 return 0; 115 } 116 117 static int drm_gem_one_name_info(int id, void *ptr, void *data) 118 { 119 struct drm_gem_object *obj = ptr; 120 struct seq_file *m = data; 121 122 seq_printf(m, "%6d %8zd %7d %8d\n", 123 obj->name, obj->size, 124 obj->handle_count, 125 kref_read(&obj->refcount)); 126 return 0; 127 } 128 129 static int drm_gem_name_info(struct seq_file *m, void *data) 130 { 131 struct drm_debugfs_entry *entry = m->private; 132 struct drm_device *dev = entry->dev; 133 134 seq_printf(m, " name size handles refcount\n"); 135 136 mutex_lock(&dev->object_name_lock); 137 idr_for_each(&dev->object_name_idr, drm_gem_one_name_info, m); 138 mutex_unlock(&dev->object_name_lock); 139 140 return 0; 141 } 142 143 static const struct drm_debugfs_info drm_debugfs_list[] = { 144 {"name", drm_name_info, 0}, 145 {"clients", drm_clients_info, 0}, 146 {"gem_names", drm_gem_name_info, DRIVER_GEM}, 147 }; 148 #define DRM_DEBUGFS_ENTRIES ARRAY_SIZE(drm_debugfs_list) 149 150 151 static int drm_debugfs_open(struct inode *inode, struct file *file) 152 { 153 struct drm_info_node *node = inode->i_private; 154 155 if (!device_is_registered(node->minor->kdev)) 156 return -ENODEV; 157 158 return single_open(file, node->info_ent->show, node); 159 } 160 161 static int drm_debugfs_entry_open(struct inode *inode, struct file *file) 162 { 163 struct drm_debugfs_entry *entry = inode->i_private; 164 struct drm_debugfs_info *node = &entry->file; 165 struct drm_minor *minor = entry->dev->primary ?: entry->dev->accel; 166 167 if (!device_is_registered(minor->kdev)) 168 return -ENODEV; 169 170 return single_open(file, node->show, entry); 171 } 172 173 static const struct file_operations drm_debugfs_entry_fops = { 174 .owner = THIS_MODULE, 175 .open = drm_debugfs_entry_open, 176 .read = seq_read, 177 .llseek = seq_lseek, 178 .release = single_release, 179 }; 180 181 static const struct file_operations drm_debugfs_fops = { 182 .owner = THIS_MODULE, 183 .open = drm_debugfs_open, 184 .read = seq_read, 185 .llseek = seq_lseek, 186 .release = single_release, 187 }; 188 189 /** 190 * drm_debugfs_gpuva_info - dump the given DRM GPU VA space 191 * @m: pointer to the &seq_file to write 192 * @gpuvm: the &drm_gpuvm representing the GPU VA space 193 * 194 * Dumps the GPU VA mappings of a given DRM GPU VA manager. 195 * 196 * For each DRM GPU VA space drivers should call this function from their 197 * &drm_info_list's show callback. 198 * 199 * Returns: 0 on success, -ENODEV if the &gpuvm is not initialized 200 */ 201 int drm_debugfs_gpuva_info(struct seq_file *m, 202 struct drm_gpuvm *gpuvm) 203 { 204 struct drm_gpuva *va, *kva = &gpuvm->kernel_alloc_node; 205 206 if (!gpuvm->name) 207 return -ENODEV; 208 209 seq_printf(m, "DRM GPU VA space (%s) [0x%016llx;0x%016llx]\n", 210 gpuvm->name, gpuvm->mm_start, gpuvm->mm_start + gpuvm->mm_range); 211 seq_printf(m, "Kernel reserved node [0x%016llx;0x%016llx]\n", 212 kva->va.addr, kva->va.addr + kva->va.range); 213 seq_puts(m, "\n"); 214 seq_puts(m, " VAs | start | range | end | object | object offset\n"); 215 seq_puts(m, "-------------------------------------------------------------------------------------------------------------\n"); 216 drm_gpuvm_for_each_va(va, gpuvm) { 217 if (unlikely(va == kva)) 218 continue; 219 220 seq_printf(m, " | 0x%016llx | 0x%016llx | 0x%016llx | 0x%016llx | 0x%016llx\n", 221 va->va.addr, va->va.range, va->va.addr + va->va.range, 222 (u64)(uintptr_t)va->gem.obj, va->gem.offset); 223 } 224 225 return 0; 226 } 227 EXPORT_SYMBOL(drm_debugfs_gpuva_info); 228 229 /** 230 * drm_debugfs_create_files - Initialize a given set of debugfs files for DRM 231 * minor 232 * @files: The array of files to create 233 * @count: The number of files given 234 * @root: DRI debugfs dir entry. 235 * @minor: device minor number 236 * 237 * Create a given set of debugfs files represented by an array of 238 * &struct drm_info_list in the given root directory. These files will be removed 239 * automatically on drm_debugfs_dev_fini(). 240 */ 241 void drm_debugfs_create_files(const struct drm_info_list *files, int count, 242 struct dentry *root, struct drm_minor *minor) 243 { 244 struct drm_device *dev = minor->dev; 245 struct drm_info_node *tmp; 246 int i; 247 248 for (i = 0; i < count; i++) { 249 u32 features = files[i].driver_features; 250 251 if (features && !drm_core_check_all_features(dev, features)) 252 continue; 253 254 tmp = drmm_kzalloc(dev, sizeof(*tmp), GFP_KERNEL); 255 if (tmp == NULL) 256 continue; 257 258 tmp->minor = minor; 259 tmp->dent = debugfs_create_file(files[i].name, 260 0444, root, tmp, 261 &drm_debugfs_fops); 262 tmp->info_ent = &files[i]; 263 } 264 } 265 EXPORT_SYMBOL(drm_debugfs_create_files); 266 267 int drm_debugfs_remove_files(const struct drm_info_list *files, int count, 268 struct dentry *root, struct drm_minor *minor) 269 { 270 int i; 271 272 for (i = 0; i < count; i++) { 273 struct dentry *dent = debugfs_lookup(files[i].name, root); 274 275 if (!dent) 276 continue; 277 278 drmm_kfree(minor->dev, d_inode(dent)->i_private); 279 debugfs_remove(dent); 280 } 281 return 0; 282 } 283 EXPORT_SYMBOL(drm_debugfs_remove_files); 284 285 /** 286 * drm_debugfs_dev_init - create debugfs directory for the device 287 * @dev: the device which we want to create the directory for 288 * @root: the parent directory depending on the device type 289 * 290 * Creates the debugfs directory for the device under the given root directory. 291 */ 292 void drm_debugfs_dev_init(struct drm_device *dev, struct dentry *root) 293 { 294 dev->debugfs_root = debugfs_create_dir(dev->unique, root); 295 } 296 297 /** 298 * drm_debugfs_dev_fini - cleanup debugfs directory 299 * @dev: the device to cleanup the debugfs stuff 300 * 301 * Remove the debugfs directory, might be called multiple times. 302 */ 303 void drm_debugfs_dev_fini(struct drm_device *dev) 304 { 305 debugfs_remove_recursive(dev->debugfs_root); 306 dev->debugfs_root = NULL; 307 } 308 309 void drm_debugfs_dev_register(struct drm_device *dev) 310 { 311 drm_debugfs_add_files(dev, drm_debugfs_list, DRM_DEBUGFS_ENTRIES); 312 313 if (drm_core_check_feature(dev, DRIVER_MODESET)) { 314 drm_framebuffer_debugfs_init(dev); 315 drm_client_debugfs_init(dev); 316 } 317 if (drm_drv_uses_atomic_modeset(dev)) { 318 drm_atomic_debugfs_init(dev); 319 drm_bridge_debugfs_init(dev); 320 } 321 } 322 323 int drm_debugfs_register(struct drm_minor *minor, int minor_id, 324 struct dentry *root) 325 { 326 struct drm_device *dev = minor->dev; 327 char name[64]; 328 329 sprintf(name, "%d", minor_id); 330 minor->debugfs_symlink = debugfs_create_symlink(name, root, 331 dev->unique); 332 333 /* TODO: Only for compatibility with drivers */ 334 minor->debugfs_root = dev->debugfs_root; 335 336 if (dev->driver->debugfs_init && dev->render != minor) 337 dev->driver->debugfs_init(minor); 338 339 return 0; 340 } 341 342 void drm_debugfs_unregister(struct drm_minor *minor) 343 { 344 debugfs_remove(minor->debugfs_symlink); 345 minor->debugfs_symlink = NULL; 346 } 347 348 /** 349 * drm_debugfs_add_file - Add a given file to the DRM device debugfs file list 350 * @dev: drm device for the ioctl 351 * @name: debugfs file name 352 * @show: show callback 353 * @data: driver-private data, should not be device-specific 354 * 355 * Add a given file entry to the DRM device debugfs file list to be created on 356 * drm_debugfs_init. 357 */ 358 void drm_debugfs_add_file(struct drm_device *dev, const char *name, 359 int (*show)(struct seq_file*, void*), void *data) 360 { 361 struct drm_debugfs_entry *entry = drmm_kzalloc(dev, sizeof(*entry), GFP_KERNEL); 362 363 if (!entry) 364 return; 365 366 entry->file.name = name; 367 entry->file.show = show; 368 entry->file.data = data; 369 entry->dev = dev; 370 371 debugfs_create_file(name, 0444, dev->debugfs_root, entry, 372 &drm_debugfs_entry_fops); 373 } 374 EXPORT_SYMBOL(drm_debugfs_add_file); 375 376 /** 377 * drm_debugfs_add_files - Add an array of files to the DRM device debugfs file list 378 * @dev: drm device for the ioctl 379 * @files: The array of files to create 380 * @count: The number of files given 381 * 382 * Add a given set of debugfs files represented by an array of 383 * &struct drm_debugfs_info in the DRM device debugfs file list. 384 */ 385 void drm_debugfs_add_files(struct drm_device *dev, const struct drm_debugfs_info *files, int count) 386 { 387 int i; 388 389 for (i = 0; i < count; i++) 390 drm_debugfs_add_file(dev, files[i].name, files[i].show, files[i].data); 391 } 392 EXPORT_SYMBOL(drm_debugfs_add_files); 393 394 static int connector_show(struct seq_file *m, void *data) 395 { 396 struct drm_connector *connector = m->private; 397 398 seq_printf(m, "%s\n", drm_get_connector_force_name(connector->force)); 399 400 return 0; 401 } 402 403 static int connector_open(struct inode *inode, struct file *file) 404 { 405 struct drm_connector *dev = inode->i_private; 406 407 return single_open(file, connector_show, dev); 408 } 409 410 static ssize_t connector_write(struct file *file, const char __user *ubuf, 411 size_t len, loff_t *offp) 412 { 413 struct seq_file *m = file->private_data; 414 struct drm_connector *connector = m->private; 415 char buf[12]; 416 417 if (len > sizeof(buf) - 1) 418 return -EINVAL; 419 420 if (copy_from_user(buf, ubuf, len)) 421 return -EFAULT; 422 423 buf[len] = '\0'; 424 425 if (sysfs_streq(buf, "on")) 426 connector->force = DRM_FORCE_ON; 427 else if (sysfs_streq(buf, "digital")) 428 connector->force = DRM_FORCE_ON_DIGITAL; 429 else if (sysfs_streq(buf, "off")) 430 connector->force = DRM_FORCE_OFF; 431 else if (sysfs_streq(buf, "unspecified")) 432 connector->force = DRM_FORCE_UNSPECIFIED; 433 else 434 return -EINVAL; 435 436 return len; 437 } 438 439 static int edid_show(struct seq_file *m, void *data) 440 { 441 return drm_edid_override_show(m->private, m); 442 } 443 444 static int edid_open(struct inode *inode, struct file *file) 445 { 446 struct drm_connector *dev = inode->i_private; 447 448 return single_open(file, edid_show, dev); 449 } 450 451 static ssize_t edid_write(struct file *file, const char __user *ubuf, 452 size_t len, loff_t *offp) 453 { 454 struct seq_file *m = file->private_data; 455 struct drm_connector *connector = m->private; 456 char *buf; 457 int ret; 458 459 buf = memdup_user(ubuf, len); 460 if (IS_ERR(buf)) 461 return PTR_ERR(buf); 462 463 if (len == 5 && !strncmp(buf, "reset", 5)) 464 ret = drm_edid_override_reset(connector); 465 else 466 ret = drm_edid_override_set(connector, buf, len); 467 468 kfree(buf); 469 470 return ret ? ret : len; 471 } 472 473 /* 474 * Returns the min and max vrr vfreq through the connector's debugfs file. 475 * Example usage: cat /sys/kernel/debug/dri/0/DP-1/vrr_range 476 */ 477 static int vrr_range_show(struct seq_file *m, void *data) 478 { 479 struct drm_connector *connector = m->private; 480 481 if (connector->status != connector_status_connected) 482 return -ENODEV; 483 484 seq_printf(m, "Min: %u\n", connector->display_info.monitor_range.min_vfreq); 485 seq_printf(m, "Max: %u\n", connector->display_info.monitor_range.max_vfreq); 486 487 return 0; 488 } 489 DEFINE_SHOW_ATTRIBUTE(vrr_range); 490 491 /* 492 * Returns Connector's max supported bpc through debugfs file. 493 * Example usage: cat /sys/kernel/debug/dri/0/DP-1/output_bpc 494 */ 495 static int output_bpc_show(struct seq_file *m, void *data) 496 { 497 struct drm_connector *connector = m->private; 498 499 if (connector->status != connector_status_connected) 500 return -ENODEV; 501 502 seq_printf(m, "Maximum: %u\n", connector->display_info.bpc); 503 504 return 0; 505 } 506 DEFINE_SHOW_ATTRIBUTE(output_bpc); 507 508 static const struct file_operations drm_edid_fops = { 509 .owner = THIS_MODULE, 510 .open = edid_open, 511 .read = seq_read, 512 .llseek = seq_lseek, 513 .release = single_release, 514 .write = edid_write 515 }; 516 517 518 static const struct file_operations drm_connector_fops = { 519 .owner = THIS_MODULE, 520 .open = connector_open, 521 .read = seq_read, 522 .llseek = seq_lseek, 523 .release = single_release, 524 .write = connector_write 525 }; 526 527 void drm_debugfs_connector_add(struct drm_connector *connector) 528 { 529 struct drm_device *dev = connector->dev; 530 struct dentry *root; 531 532 if (!dev->debugfs_root) 533 return; 534 535 root = debugfs_create_dir(connector->name, dev->debugfs_root); 536 connector->debugfs_entry = root; 537 538 /* force */ 539 debugfs_create_file("force", 0644, root, connector, 540 &drm_connector_fops); 541 542 /* edid */ 543 debugfs_create_file("edid_override", 0644, root, connector, 544 &drm_edid_fops); 545 546 /* vrr range */ 547 debugfs_create_file("vrr_range", 0444, root, connector, 548 &vrr_range_fops); 549 550 /* max bpc */ 551 debugfs_create_file("output_bpc", 0444, root, connector, 552 &output_bpc_fops); 553 554 if (connector->funcs->debugfs_init) 555 connector->funcs->debugfs_init(connector, root); 556 } 557 558 void drm_debugfs_connector_remove(struct drm_connector *connector) 559 { 560 if (!connector->debugfs_entry) 561 return; 562 563 debugfs_remove_recursive(connector->debugfs_entry); 564 565 connector->debugfs_entry = NULL; 566 } 567 568 void drm_debugfs_crtc_add(struct drm_crtc *crtc) 569 { 570 struct drm_device *dev = crtc->dev; 571 struct dentry *root; 572 char *name; 573 574 name = kasprintf(GFP_KERNEL, "crtc-%d", crtc->index); 575 if (!name) 576 return; 577 578 root = debugfs_create_dir(name, dev->debugfs_root); 579 kfree(name); 580 581 crtc->debugfs_entry = root; 582 583 drm_debugfs_crtc_crc_add(crtc); 584 } 585 586 void drm_debugfs_crtc_remove(struct drm_crtc *crtc) 587 { 588 debugfs_remove_recursive(crtc->debugfs_entry); 589 crtc->debugfs_entry = NULL; 590 } 591 592 #endif /* CONFIG_DEBUG_FS */ 593