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_client.h> 35 #include <drm/drm_debugfs.h> 36 #include <drm/drm_device.h> 37 #include <drm/drm_drv.h> 38 #include <drm/drm_edid.h> 39 #include <drm/drm_file.h> 40 #include <drm/drm_gem.h> 41 #include <drm/drm_managed.h> 42 43 #include "drm_crtc_internal.h" 44 #include "drm_internal.h" 45 46 #if defined(CONFIG_DEBUG_FS) 47 48 /*************************************************** 49 * Initialization, etc. 50 **************************************************/ 51 52 static int drm_name_info(struct seq_file *m, void *data) 53 { 54 struct drm_debugfs_entry *entry = m->private; 55 struct drm_device *dev = entry->dev; 56 struct drm_master *master; 57 58 mutex_lock(&dev->master_mutex); 59 master = dev->master; 60 seq_printf(m, "%s", dev->driver->name); 61 if (dev->dev) 62 seq_printf(m, " dev=%s", dev_name(dev->dev)); 63 if (master && master->unique) 64 seq_printf(m, " master=%s", master->unique); 65 if (dev->unique) 66 seq_printf(m, " unique=%s", dev->unique); 67 seq_printf(m, "\n"); 68 mutex_unlock(&dev->master_mutex); 69 70 return 0; 71 } 72 73 static int drm_clients_info(struct seq_file *m, void *data) 74 { 75 struct drm_debugfs_entry *entry = m->private; 76 struct drm_device *dev = entry->dev; 77 struct drm_file *priv; 78 kuid_t uid; 79 80 seq_printf(m, 81 "%20s %5s %3s master a %5s %10s\n", 82 "command", 83 "pid", 84 "dev", 85 "uid", 86 "magic"); 87 88 /* dev->filelist is sorted youngest first, but we want to present 89 * oldest first (i.e. kernel, servers, clients), so walk backwardss. 90 */ 91 mutex_lock(&dev->filelist_mutex); 92 list_for_each_entry_reverse(priv, &dev->filelist, lhead) { 93 struct task_struct *task; 94 bool is_current_master = drm_is_current_master(priv); 95 96 rcu_read_lock(); /* locks pid_task()->comm */ 97 task = pid_task(priv->pid, PIDTYPE_PID); 98 uid = task ? __task_cred(task)->euid : GLOBAL_ROOT_UID; 99 seq_printf(m, "%20s %5d %3d %c %c %5d %10u\n", 100 task ? task->comm : "<unknown>", 101 pid_vnr(priv->pid), 102 priv->minor->index, 103 is_current_master ? 'y' : 'n', 104 priv->authenticated ? 'y' : 'n', 105 from_kuid_munged(seq_user_ns(m), uid), 106 priv->magic); 107 rcu_read_unlock(); 108 } 109 mutex_unlock(&dev->filelist_mutex); 110 return 0; 111 } 112 113 static int drm_gem_one_name_info(int id, void *ptr, void *data) 114 { 115 struct drm_gem_object *obj = ptr; 116 struct seq_file *m = data; 117 118 seq_printf(m, "%6d %8zd %7d %8d\n", 119 obj->name, obj->size, 120 obj->handle_count, 121 kref_read(&obj->refcount)); 122 return 0; 123 } 124 125 static int drm_gem_name_info(struct seq_file *m, void *data) 126 { 127 struct drm_debugfs_entry *entry = m->private; 128 struct drm_device *dev = entry->dev; 129 130 seq_printf(m, " name size handles refcount\n"); 131 132 mutex_lock(&dev->object_name_lock); 133 idr_for_each(&dev->object_name_idr, drm_gem_one_name_info, m); 134 mutex_unlock(&dev->object_name_lock); 135 136 return 0; 137 } 138 139 static const struct drm_debugfs_info drm_debugfs_list[] = { 140 {"name", drm_name_info, 0}, 141 {"clients", drm_clients_info, 0}, 142 {"gem_names", drm_gem_name_info, DRIVER_GEM}, 143 }; 144 #define DRM_DEBUGFS_ENTRIES ARRAY_SIZE(drm_debugfs_list) 145 146 147 static int drm_debugfs_open(struct inode *inode, struct file *file) 148 { 149 struct drm_info_node *node = inode->i_private; 150 151 return single_open(file, node->info_ent->show, node); 152 } 153 154 static int drm_debugfs_entry_open(struct inode *inode, struct file *file) 155 { 156 struct drm_debugfs_entry *entry = inode->i_private; 157 struct drm_debugfs_info *node = &entry->file; 158 159 return single_open(file, node->show, entry); 160 } 161 162 static const struct file_operations drm_debugfs_entry_fops = { 163 .owner = THIS_MODULE, 164 .open = drm_debugfs_entry_open, 165 .read = seq_read, 166 .llseek = seq_lseek, 167 .release = single_release, 168 }; 169 170 static const struct file_operations drm_debugfs_fops = { 171 .owner = THIS_MODULE, 172 .open = drm_debugfs_open, 173 .read = seq_read, 174 .llseek = seq_lseek, 175 .release = single_release, 176 }; 177 178 179 /** 180 * drm_debugfs_create_files - Initialize a given set of debugfs files for DRM 181 * minor 182 * @files: The array of files to create 183 * @count: The number of files given 184 * @root: DRI debugfs dir entry. 185 * @minor: device minor number 186 * 187 * Create a given set of debugfs files represented by an array of 188 * &struct drm_info_list in the given root directory. These files will be removed 189 * automatically on drm_debugfs_cleanup(). 190 */ 191 void drm_debugfs_create_files(const struct drm_info_list *files, int count, 192 struct dentry *root, struct drm_minor *minor) 193 { 194 struct drm_device *dev = minor->dev; 195 struct drm_info_node *tmp; 196 int i; 197 198 for (i = 0; i < count; i++) { 199 u32 features = files[i].driver_features; 200 201 if (features && !drm_core_check_all_features(dev, features)) 202 continue; 203 204 tmp = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL); 205 if (tmp == NULL) 206 continue; 207 208 tmp->minor = minor; 209 tmp->dent = debugfs_create_file(files[i].name, 210 0444, root, tmp, 211 &drm_debugfs_fops); 212 tmp->info_ent = &files[i]; 213 214 mutex_lock(&minor->debugfs_lock); 215 list_add(&tmp->list, &minor->debugfs_list); 216 mutex_unlock(&minor->debugfs_lock); 217 } 218 } 219 EXPORT_SYMBOL(drm_debugfs_create_files); 220 221 int drm_debugfs_init(struct drm_minor *minor, int minor_id, 222 struct dentry *root) 223 { 224 struct drm_device *dev = minor->dev; 225 struct drm_debugfs_entry *entry, *tmp; 226 char name[64]; 227 228 INIT_LIST_HEAD(&minor->debugfs_list); 229 mutex_init(&minor->debugfs_lock); 230 sprintf(name, "%d", minor_id); 231 minor->debugfs_root = debugfs_create_dir(name, root); 232 233 drm_debugfs_add_files(minor->dev, drm_debugfs_list, DRM_DEBUGFS_ENTRIES); 234 235 if (drm_drv_uses_atomic_modeset(dev)) { 236 drm_atomic_debugfs_init(minor); 237 } 238 239 if (drm_core_check_feature(dev, DRIVER_MODESET)) { 240 drm_framebuffer_debugfs_init(minor); 241 242 drm_client_debugfs_init(minor); 243 } 244 245 if (dev->driver->debugfs_init) 246 dev->driver->debugfs_init(minor); 247 248 list_for_each_entry_safe(entry, tmp, &dev->debugfs_list, list) { 249 debugfs_create_file(entry->file.name, 0444, 250 minor->debugfs_root, entry, &drm_debugfs_entry_fops); 251 list_del(&entry->list); 252 } 253 254 return 0; 255 } 256 257 void drm_debugfs_late_register(struct drm_device *dev) 258 { 259 struct drm_minor *minor = dev->primary; 260 struct drm_debugfs_entry *entry, *tmp; 261 262 if (!minor) 263 return; 264 265 list_for_each_entry_safe(entry, tmp, &dev->debugfs_list, list) { 266 debugfs_create_file(entry->file.name, 0444, 267 minor->debugfs_root, entry, &drm_debugfs_entry_fops); 268 list_del(&entry->list); 269 } 270 } 271 272 int drm_debugfs_remove_files(const struct drm_info_list *files, int count, 273 struct drm_minor *minor) 274 { 275 struct list_head *pos, *q; 276 struct drm_info_node *tmp; 277 int i; 278 279 mutex_lock(&minor->debugfs_lock); 280 for (i = 0; i < count; i++) { 281 list_for_each_safe(pos, q, &minor->debugfs_list) { 282 tmp = list_entry(pos, struct drm_info_node, list); 283 if (tmp->info_ent == &files[i]) { 284 debugfs_remove(tmp->dent); 285 list_del(pos); 286 kfree(tmp); 287 } 288 } 289 } 290 mutex_unlock(&minor->debugfs_lock); 291 return 0; 292 } 293 EXPORT_SYMBOL(drm_debugfs_remove_files); 294 295 static void drm_debugfs_remove_all_files(struct drm_minor *minor) 296 { 297 struct drm_info_node *node, *tmp; 298 299 mutex_lock(&minor->debugfs_lock); 300 list_for_each_entry_safe(node, tmp, &minor->debugfs_list, list) { 301 debugfs_remove(node->dent); 302 list_del(&node->list); 303 kfree(node); 304 } 305 mutex_unlock(&minor->debugfs_lock); 306 } 307 308 void drm_debugfs_cleanup(struct drm_minor *minor) 309 { 310 if (!minor->debugfs_root) 311 return; 312 313 drm_debugfs_remove_all_files(minor); 314 315 debugfs_remove_recursive(minor->debugfs_root); 316 minor->debugfs_root = NULL; 317 } 318 319 /** 320 * drm_debugfs_add_file - Add a given file to the DRM device debugfs file list 321 * @dev: drm device for the ioctl 322 * @name: debugfs file name 323 * @show: show callback 324 * @data: driver-private data, should not be device-specific 325 * 326 * Add a given file entry to the DRM device debugfs file list to be created on 327 * drm_debugfs_init. 328 */ 329 void drm_debugfs_add_file(struct drm_device *dev, const char *name, 330 int (*show)(struct seq_file*, void*), void *data) 331 { 332 struct drm_debugfs_entry *entry = drmm_kzalloc(dev, sizeof(*entry), GFP_KERNEL); 333 334 if (!entry) 335 return; 336 337 entry->file.name = name; 338 entry->file.show = show; 339 entry->file.data = data; 340 entry->dev = dev; 341 342 mutex_lock(&dev->debugfs_mutex); 343 list_add(&entry->list, &dev->debugfs_list); 344 mutex_unlock(&dev->debugfs_mutex); 345 } 346 EXPORT_SYMBOL(drm_debugfs_add_file); 347 348 /** 349 * drm_debugfs_add_files - Add an array of files to the DRM device debugfs file list 350 * @dev: drm device for the ioctl 351 * @files: The array of files to create 352 * @count: The number of files given 353 * 354 * Add a given set of debugfs files represented by an array of 355 * &struct drm_debugfs_info in the DRM device debugfs file list. 356 */ 357 void drm_debugfs_add_files(struct drm_device *dev, const struct drm_debugfs_info *files, int count) 358 { 359 int i; 360 361 for (i = 0; i < count; i++) 362 drm_debugfs_add_file(dev, files[i].name, files[i].show, files[i].data); 363 } 364 EXPORT_SYMBOL(drm_debugfs_add_files); 365 366 static int connector_show(struct seq_file *m, void *data) 367 { 368 struct drm_connector *connector = m->private; 369 370 seq_printf(m, "%s\n", drm_get_connector_force_name(connector->force)); 371 372 return 0; 373 } 374 375 static int connector_open(struct inode *inode, struct file *file) 376 { 377 struct drm_connector *dev = inode->i_private; 378 379 return single_open(file, connector_show, dev); 380 } 381 382 static ssize_t connector_write(struct file *file, const char __user *ubuf, 383 size_t len, loff_t *offp) 384 { 385 struct seq_file *m = file->private_data; 386 struct drm_connector *connector = m->private; 387 char buf[12]; 388 389 if (len > sizeof(buf) - 1) 390 return -EINVAL; 391 392 if (copy_from_user(buf, ubuf, len)) 393 return -EFAULT; 394 395 buf[len] = '\0'; 396 397 if (sysfs_streq(buf, "on")) 398 connector->force = DRM_FORCE_ON; 399 else if (sysfs_streq(buf, "digital")) 400 connector->force = DRM_FORCE_ON_DIGITAL; 401 else if (sysfs_streq(buf, "off")) 402 connector->force = DRM_FORCE_OFF; 403 else if (sysfs_streq(buf, "unspecified")) 404 connector->force = DRM_FORCE_UNSPECIFIED; 405 else 406 return -EINVAL; 407 408 return len; 409 } 410 411 static int edid_show(struct seq_file *m, void *data) 412 { 413 return drm_edid_override_show(m->private, m); 414 } 415 416 static int edid_open(struct inode *inode, struct file *file) 417 { 418 struct drm_connector *dev = inode->i_private; 419 420 return single_open(file, edid_show, dev); 421 } 422 423 static ssize_t edid_write(struct file *file, const char __user *ubuf, 424 size_t len, loff_t *offp) 425 { 426 struct seq_file *m = file->private_data; 427 struct drm_connector *connector = m->private; 428 char *buf; 429 int ret; 430 431 buf = memdup_user(ubuf, len); 432 if (IS_ERR(buf)) 433 return PTR_ERR(buf); 434 435 if (len == 5 && !strncmp(buf, "reset", 5)) 436 ret = drm_edid_override_reset(connector); 437 else 438 ret = drm_edid_override_set(connector, buf, len); 439 440 kfree(buf); 441 442 return ret ? ret : len; 443 } 444 445 /* 446 * Returns the min and max vrr vfreq through the connector's debugfs file. 447 * Example usage: cat /sys/kernel/debug/dri/0/DP-1/vrr_range 448 */ 449 static int vrr_range_show(struct seq_file *m, void *data) 450 { 451 struct drm_connector *connector = m->private; 452 453 if (connector->status != connector_status_connected) 454 return -ENODEV; 455 456 seq_printf(m, "Min: %u\n", connector->display_info.monitor_range.min_vfreq); 457 seq_printf(m, "Max: %u\n", connector->display_info.monitor_range.max_vfreq); 458 459 return 0; 460 } 461 DEFINE_SHOW_ATTRIBUTE(vrr_range); 462 463 /* 464 * Returns Connector's max supported bpc through debugfs file. 465 * Example usage: cat /sys/kernel/debug/dri/0/DP-1/output_bpc 466 */ 467 static int output_bpc_show(struct seq_file *m, void *data) 468 { 469 struct drm_connector *connector = m->private; 470 471 if (connector->status != connector_status_connected) 472 return -ENODEV; 473 474 seq_printf(m, "Maximum: %u\n", connector->display_info.bpc); 475 476 return 0; 477 } 478 DEFINE_SHOW_ATTRIBUTE(output_bpc); 479 480 static const struct file_operations drm_edid_fops = { 481 .owner = THIS_MODULE, 482 .open = edid_open, 483 .read = seq_read, 484 .llseek = seq_lseek, 485 .release = single_release, 486 .write = edid_write 487 }; 488 489 490 static const struct file_operations drm_connector_fops = { 491 .owner = THIS_MODULE, 492 .open = connector_open, 493 .read = seq_read, 494 .llseek = seq_lseek, 495 .release = single_release, 496 .write = connector_write 497 }; 498 499 void drm_debugfs_connector_add(struct drm_connector *connector) 500 { 501 struct drm_minor *minor = connector->dev->primary; 502 struct dentry *root; 503 504 if (!minor->debugfs_root) 505 return; 506 507 root = debugfs_create_dir(connector->name, minor->debugfs_root); 508 connector->debugfs_entry = root; 509 510 /* force */ 511 debugfs_create_file("force", 0644, root, connector, 512 &drm_connector_fops); 513 514 /* edid */ 515 debugfs_create_file("edid_override", 0644, root, connector, 516 &drm_edid_fops); 517 518 /* vrr range */ 519 debugfs_create_file("vrr_range", 0444, root, connector, 520 &vrr_range_fops); 521 522 /* max bpc */ 523 debugfs_create_file("output_bpc", 0444, root, connector, 524 &output_bpc_fops); 525 526 if (connector->funcs->debugfs_init) 527 connector->funcs->debugfs_init(connector, root); 528 } 529 530 void drm_debugfs_connector_remove(struct drm_connector *connector) 531 { 532 if (!connector->debugfs_entry) 533 return; 534 535 debugfs_remove_recursive(connector->debugfs_entry); 536 537 connector->debugfs_entry = NULL; 538 } 539 540 void drm_debugfs_crtc_add(struct drm_crtc *crtc) 541 { 542 struct drm_minor *minor = crtc->dev->primary; 543 struct dentry *root; 544 char *name; 545 546 name = kasprintf(GFP_KERNEL, "crtc-%d", crtc->index); 547 if (!name) 548 return; 549 550 root = debugfs_create_dir(name, minor->debugfs_root); 551 kfree(name); 552 553 crtc->debugfs_entry = root; 554 555 drm_debugfs_crtc_crc_add(crtc); 556 } 557 558 void drm_debugfs_crtc_remove(struct drm_crtc *crtc) 559 { 560 debugfs_remove_recursive(crtc->debugfs_entry); 561 crtc->debugfs_entry = NULL; 562 } 563 564 #endif /* CONFIG_DEBUG_FS */ 565