1 /* $NetBSD: drm_debugfs.c,v 1.5 2021/12/18 23:44:57 riastradh Exp $ */ 2 3 /* 4 * Created: Sun Dec 21 13:08:50 2008 by bgamari (at) gmail.com 5 * 6 * Copyright 2008 Ben Gamari <bgamari (at) gmail.com> 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a 9 * copy of this software and associated documentation files (the "Software"), 10 * to deal in the Software without restriction, including without limitation 11 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 12 * and/or sell copies of the Software, and to permit persons to whom the 13 * Software is furnished to do so, subject to the following conditions: 14 * 15 * The above copyright notice and this permission notice (including the next 16 * paragraph) shall be included in all copies or substantial portions of the 17 * Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 22 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 23 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 24 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 * OTHER DEALINGS IN THE SOFTWARE. 26 */ 27 28 #include <sys/cdefs.h> 29 __KERNEL_RCSID(0, "$NetBSD: drm_debugfs.c,v 1.5 2021/12/18 23:44:57 riastradh Exp $"); 30 31 #include <linux/debugfs.h> 32 #include <linux/export.h> 33 #include <linux/seq_file.h> 34 #include <linux/slab.h> 35 #include <linux/uaccess.h> 36 37 #include <drm/drm_atomic.h> 38 #include <drm/drm_auth.h> 39 #include <drm/drm_client.h> 40 #include <drm/drm_debugfs.h> 41 #include <drm/drm_device.h> 42 #include <drm/drm_drv.h> 43 #include <drm/drm_edid.h> 44 #include <drm/drm_file.h> 45 #include <drm/drm_gem.h> 46 47 #include "drm_crtc_internal.h" 48 #include "drm_internal.h" 49 50 #if defined(CONFIG_DEBUG_FS) 51 52 /*************************************************** 53 * Initialization, etc. 54 **************************************************/ 55 56 static int drm_name_info(struct seq_file *m, void *data) 57 { 58 struct drm_info_node *node = (struct drm_info_node *) m->private; 59 struct drm_minor *minor = node->minor; 60 struct drm_device *dev = minor->dev; 61 struct drm_master *master; 62 63 mutex_lock(&dev->master_mutex); 64 master = dev->master; 65 seq_printf(m, "%s", dev->driver->name); 66 if (dev->dev) 67 seq_printf(m, " dev=%s", dev_name(dev->dev)); 68 if (master && master->unique) 69 seq_printf(m, " master=%s", master->unique); 70 if (dev->unique) 71 seq_printf(m, " unique=%s", dev->unique); 72 seq_printf(m, "\n"); 73 mutex_unlock(&dev->master_mutex); 74 75 return 0; 76 } 77 78 static int drm_clients_info(struct seq_file *m, void *data) 79 { 80 struct drm_info_node *node = (struct drm_info_node *) m->private; 81 struct drm_device *dev = node->minor->dev; 82 struct drm_file *priv; 83 kuid_t uid; 84 85 seq_printf(m, 86 "%20s %5s %3s master a %5s %10s\n", 87 "command", 88 "pid", 89 "dev", 90 "uid", 91 "magic"); 92 93 /* dev->filelist is sorted youngest first, but we want to present 94 * oldest first (i.e. kernel, servers, clients), so walk backwardss. 95 */ 96 mutex_lock(&dev->filelist_mutex); 97 list_for_each_entry_reverse(priv, &dev->filelist, lhead) { 98 struct task_struct *task; 99 100 rcu_read_lock(); /* locks pid_task()->comm */ 101 task = pid_task(priv->pid, PIDTYPE_PID); 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(priv->pid), 106 priv->minor->index, 107 drm_is_current_master(priv) ? '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_info_node *node = (struct drm_info_node *) m->private; 132 struct drm_device *dev = node->minor->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_info_list 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 return single_open(file, node->info_ent->show, node); 156 } 157 158 159 static const struct file_operations drm_debugfs_fops = { 160 .owner = THIS_MODULE, 161 .open = drm_debugfs_open, 162 .read = seq_read, 163 .llseek = seq_lseek, 164 .release = single_release, 165 }; 166 167 168 /** 169 * drm_debugfs_create_files - Initialize a given set of debugfs files for DRM 170 * minor 171 * @files: The array of files to create 172 * @count: The number of files given 173 * @root: DRI debugfs dir entry. 174 * @minor: device minor number 175 * 176 * Create a given set of debugfs files represented by an array of 177 * &struct drm_info_list in the given root directory. These files will be removed 178 * automatically on drm_debugfs_cleanup(). 179 */ 180 int drm_debugfs_create_files(const struct drm_info_list *files, int count, 181 struct dentry *root, struct drm_minor *minor) 182 { 183 struct drm_device *dev = minor->dev; 184 struct drm_info_node *tmp; 185 int i; 186 187 for (i = 0; i < count; i++) { 188 u32 features = files[i].driver_features; 189 190 if (features != 0 && 191 (dev->driver->driver_features & features) != features) 192 continue; 193 194 tmp = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL); 195 if (tmp == NULL) 196 continue; 197 198 tmp->minor = minor; 199 tmp->dent = debugfs_create_file(files[i].name, 200 S_IFREG | S_IRUGO, root, tmp, 201 &drm_debugfs_fops); 202 tmp->info_ent = &files[i]; 203 204 mutex_lock(&minor->debugfs_lock); 205 list_add(&tmp->list, &minor->debugfs_list); 206 mutex_unlock(&minor->debugfs_lock); 207 } 208 return 0; 209 } 210 EXPORT_SYMBOL(drm_debugfs_create_files); 211 212 int drm_debugfs_init(struct drm_minor *minor, int minor_id, 213 struct dentry *root) 214 { 215 struct drm_device *dev = minor->dev; 216 char name[64]; 217 int ret; 218 219 INIT_LIST_HEAD(&minor->debugfs_list); 220 mutex_init(&minor->debugfs_lock); 221 snprintf(name, sizeof(name), "%d", minor_id); 222 minor->debugfs_root = debugfs_create_dir(name, root); 223 224 ret = drm_debugfs_create_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES, 225 minor->debugfs_root, minor); 226 if (ret) { 227 debugfs_remove(minor->debugfs_root); 228 minor->debugfs_root = NULL; 229 DRM_ERROR("Failed to create core drm debugfs files\n"); 230 return ret; 231 } 232 233 if (drm_drv_uses_atomic_modeset(dev)) { 234 ret = drm_atomic_debugfs_init(minor); 235 if (ret) { 236 DRM_ERROR("Failed to create atomic debugfs files\n"); 237 return ret; 238 } 239 } 240 241 if (drm_core_check_feature(dev, DRIVER_MODESET)) { 242 ret = drm_framebuffer_debugfs_init(minor); 243 if (ret) { 244 DRM_ERROR("Failed to create framebuffer debugfs file\n"); 245 return ret; 246 } 247 248 ret = drm_client_debugfs_init(minor); 249 if (ret) { 250 DRM_ERROR("Failed to create client debugfs file\n"); 251 return ret; 252 } 253 } 254 255 if (dev->driver->debugfs_init) { 256 ret = dev->driver->debugfs_init(minor); 257 if (ret) { 258 DRM_ERROR("DRM: Driver failed to initialize " 259 "/sys/kernel/debug/dri.\n"); 260 return ret; 261 } 262 } 263 return 0; 264 } 265 266 267 int drm_debugfs_remove_files(const struct drm_info_list *files, int count, 268 struct drm_minor *minor) 269 { 270 struct list_head *pos, *q; 271 struct drm_info_node *tmp; 272 int i; 273 274 mutex_lock(&minor->debugfs_lock); 275 for (i = 0; i < count; i++) { 276 list_for_each_safe(pos, q, &minor->debugfs_list) { 277 tmp = list_entry(pos, struct drm_info_node, list); 278 if (tmp->info_ent == &files[i]) { 279 debugfs_remove(tmp->dent); 280 list_del(pos); 281 kfree(tmp); 282 } 283 } 284 } 285 mutex_unlock(&minor->debugfs_lock); 286 return 0; 287 } 288 EXPORT_SYMBOL(drm_debugfs_remove_files); 289 290 static void drm_debugfs_remove_all_files(struct drm_minor *minor) 291 { 292 struct drm_info_node *node, *tmp; 293 294 mutex_lock(&minor->debugfs_lock); 295 list_for_each_entry_safe(node, tmp, &minor->debugfs_list, list) { 296 debugfs_remove(node->dent); 297 list_del(&node->list); 298 kfree(node); 299 } 300 mutex_unlock(&minor->debugfs_lock); 301 } 302 303 void drm_debugfs_cleanup(struct drm_minor *minor) 304 { 305 if (!minor->debugfs_root) 306 return; 307 308 drm_debugfs_remove_all_files(minor); 309 310 debugfs_remove_recursive(minor->debugfs_root); 311 minor->debugfs_root = NULL; 312 } 313 314 static int connector_show(struct seq_file *m, void *data) 315 { 316 struct drm_connector *connector = m->private; 317 318 seq_printf(m, "%s\n", drm_get_connector_force_name(connector->force)); 319 320 return 0; 321 } 322 323 static int connector_open(struct inode *inode, struct file *file) 324 { 325 struct drm_connector *dev = inode->i_private; 326 327 return single_open(file, connector_show, dev); 328 } 329 330 static ssize_t connector_write(struct file *file, const char __user *ubuf, 331 size_t len, loff_t *offp) 332 { 333 struct seq_file *m = file->private_data; 334 struct drm_connector *connector = m->private; 335 char buf[12]; 336 337 if (len > sizeof(buf) - 1) 338 return -EINVAL; 339 340 if (copy_from_user(buf, ubuf, len)) 341 return -EFAULT; 342 343 buf[len] = '\0'; 344 345 if (!strcmp(buf, "on")) 346 connector->force = DRM_FORCE_ON; 347 else if (!strcmp(buf, "digital")) 348 connector->force = DRM_FORCE_ON_DIGITAL; 349 else if (!strcmp(buf, "off")) 350 connector->force = DRM_FORCE_OFF; 351 else if (!strcmp(buf, "unspecified")) 352 connector->force = DRM_FORCE_UNSPECIFIED; 353 else 354 return -EINVAL; 355 356 return len; 357 } 358 359 static int edid_show(struct seq_file *m, void *data) 360 { 361 struct drm_connector *connector = m->private; 362 struct drm_property_blob *edid = connector->edid_blob_ptr; 363 364 if (connector->override_edid && edid) 365 seq_write(m, edid->data, edid->length); 366 367 return 0; 368 } 369 370 static int edid_open(struct inode *inode, struct file *file) 371 { 372 struct drm_connector *dev = inode->i_private; 373 374 return single_open(file, edid_show, dev); 375 } 376 377 static ssize_t edid_write(struct file *file, const char __user *ubuf, 378 size_t len, loff_t *offp) 379 { 380 struct seq_file *m = file->private_data; 381 struct drm_connector *connector = m->private; 382 char *buf; 383 struct edid *edid; 384 int ret; 385 386 buf = memdup_user(ubuf, len); 387 if (IS_ERR(buf)) 388 return PTR_ERR(buf); 389 390 edid = (struct edid *) buf; 391 392 if (len == 5 && !strncmp(buf, "reset", 5)) { 393 connector->override_edid = false; 394 ret = drm_connector_update_edid_property(connector, NULL); 395 } else if (len < EDID_LENGTH || 396 EDID_LENGTH * (1 + edid->extensions) > len) 397 ret = -EINVAL; 398 else { 399 connector->override_edid = false; 400 ret = drm_connector_update_edid_property(connector, edid); 401 if (!ret) 402 connector->override_edid = true; 403 } 404 405 kfree(buf); 406 407 return (ret) ? ret : len; 408 } 409 410 static const struct file_operations drm_edid_fops = { 411 .owner = THIS_MODULE, 412 .open = edid_open, 413 .read = seq_read, 414 .llseek = seq_lseek, 415 .release = single_release, 416 .write = edid_write 417 }; 418 419 420 static const struct file_operations drm_connector_fops = { 421 .owner = THIS_MODULE, 422 .open = connector_open, 423 .read = seq_read, 424 .llseek = seq_lseek, 425 .release = single_release, 426 .write = connector_write 427 }; 428 429 void drm_debugfs_connector_add(struct drm_connector *connector) 430 { 431 struct drm_minor *minor = connector->dev->primary; 432 struct dentry *root; 433 434 if (!minor->debugfs_root) 435 return; 436 437 root = debugfs_create_dir(connector->name, minor->debugfs_root); 438 connector->debugfs_entry = root; 439 440 /* force */ 441 debugfs_create_file("force", S_IRUGO | S_IWUSR, root, connector, 442 &drm_connector_fops); 443 444 /* edid */ 445 debugfs_create_file("edid_override", S_IRUGO | S_IWUSR, root, connector, 446 &drm_edid_fops); 447 } 448 449 void drm_debugfs_connector_remove(struct drm_connector *connector) 450 { 451 if (!connector->debugfs_entry) 452 return; 453 454 debugfs_remove_recursive(connector->debugfs_entry); 455 456 connector->debugfs_entry = NULL; 457 } 458 459 void drm_debugfs_crtc_add(struct drm_crtc *crtc) 460 { 461 struct drm_minor *minor = crtc->dev->primary; 462 struct dentry *root; 463 char *name; 464 465 name = kasprintf(GFP_KERNEL, "crtc-%d", crtc->index); 466 if (!name) 467 return; 468 469 root = debugfs_create_dir(name, minor->debugfs_root); 470 kfree(name); 471 472 crtc->debugfs_entry = root; 473 474 drm_debugfs_crtc_crc_add(crtc); 475 } 476 477 void drm_debugfs_crtc_remove(struct drm_crtc *crtc) 478 { 479 debugfs_remove_recursive(crtc->debugfs_entry); 480 crtc->debugfs_entry = NULL; 481 } 482 483 #endif /* CONFIG_DEBUG_FS */ 484
Indexes created Tue Sep 30 11:09:46 GMT 2025