Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /** |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 2 | * \file drm_proc.c |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * /proc support for DRM |
| 4 | * |
| 5 | * \author Rickard E. (Rik) Faith <faith@valinux.com> |
| 6 | * \author Gareth Hughes <gareth@valinux.com> |
| 7 | * |
| 8 | * \par Acknowledgements: |
| 9 | * Matthew J Sottek <matthew.j.sottek@intel.com> sent in a patch to fix |
| 10 | * the problem with the proc files not outputting all their information. |
| 11 | */ |
| 12 | |
| 13 | /* |
| 14 | * Created: Mon Jan 11 09:48:47 1999 by faith@valinux.com |
| 15 | * |
| 16 | * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. |
| 17 | * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. |
| 18 | * All Rights Reserved. |
| 19 | * |
| 20 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 21 | * copy of this software and associated documentation files (the "Software"), |
| 22 | * to deal in the Software without restriction, including without limitation |
| 23 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 24 | * and/or sell copies of the Software, and to permit persons to whom the |
| 25 | * Software is furnished to do so, subject to the following conditions: |
| 26 | * |
| 27 | * The above copyright notice and this permission notice (including the next |
| 28 | * paragraph) shall be included in all copies or substantial portions of the |
| 29 | * Software. |
| 30 | * |
| 31 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 32 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 33 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 34 | * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| 35 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| 36 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| 37 | * OTHER DEALINGS IN THE SOFTWARE. |
| 38 | */ |
| 39 | |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 40 | #include <linux/seq_file.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 41 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 42 | #include "drmP.h" |
| 43 | |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 44 | /*************************************************** |
| 45 | * Initialization, etc. |
| 46 | **************************************************/ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | |
| 48 | /** |
| 49 | * Proc file list. |
| 50 | */ |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 51 | static struct drm_info_list drm_proc_list[] = { |
Eric Anholt | 673a394 | 2008-07-30 12:06:12 -0700 | [diff] [blame] | 52 | {"name", drm_name_info, 0}, |
Eric Anholt | 673a394 | 2008-07-30 12:06:12 -0700 | [diff] [blame] | 53 | {"vm", drm_vm_info, 0}, |
| 54 | {"clients", drm_clients_info, 0}, |
| 55 | {"queues", drm_queues_info, 0}, |
| 56 | {"bufs", drm_bufs_info, 0}, |
| 57 | {"gem_names", drm_gem_name_info, DRIVER_GEM}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | #if DRM_DEBUG_CODE |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 59 | {"vma", drm_vma_info, 0}, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | #endif |
| 61 | }; |
Ahmed S. Darwish | 8311d57 | 2007-02-09 10:30:10 +1100 | [diff] [blame] | 62 | #define DRM_PROC_ENTRIES ARRAY_SIZE(drm_proc_list) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 64 | static int drm_proc_open(struct inode *inode, struct file *file) |
| 65 | { |
| 66 | struct drm_info_node* node = PDE(inode)->data; |
| 67 | |
| 68 | return single_open(file, node->info_ent->show, node); |
| 69 | } |
| 70 | |
| 71 | static const struct file_operations drm_proc_fops = { |
| 72 | .owner = THIS_MODULE, |
| 73 | .open = drm_proc_open, |
| 74 | .read = seq_read, |
| 75 | .llseek = seq_lseek, |
| 76 | .release = single_release, |
| 77 | }; |
| 78 | |
| 79 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | /** |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 81 | * Initialize a given set of proc files for a device |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 82 | * |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 83 | * \param files The array of files to create |
| 84 | * \param count The number of files given |
| 85 | * \param root DRI proc dir entry. |
| 86 | * \param minor device minor number |
| 87 | * \return Zero on success, non-zero on failure |
| 88 | * |
| 89 | * Create a given set of proc files represented by an array of |
| 90 | * gdm_proc_lists in the given root directory. |
| 91 | */ |
| 92 | int drm_proc_create_files(struct drm_info_list *files, int count, |
| 93 | struct proc_dir_entry *root, struct drm_minor *minor) |
| 94 | { |
| 95 | struct drm_device *dev = minor->dev; |
| 96 | struct proc_dir_entry *ent; |
| 97 | struct drm_info_node *tmp; |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 98 | int i, ret; |
| 99 | |
| 100 | for (i = 0; i < count; i++) { |
| 101 | u32 features = files[i].driver_features; |
| 102 | |
| 103 | if (features != 0 && |
| 104 | (dev->driver->driver_features & features) != features) |
| 105 | continue; |
| 106 | |
Eric Anholt | 9a298b2 | 2009-03-24 12:23:04 -0700 | [diff] [blame] | 107 | tmp = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL); |
Roel Kluin | 1ae7007 | 2009-08-29 22:20:34 +0200 | [diff] [blame] | 108 | if (tmp == NULL) { |
| 109 | ret = -1; |
| 110 | goto fail; |
| 111 | } |
Alexey Dobriyan | 3b51096 | 2009-08-28 22:58:07 +0400 | [diff] [blame] | 112 | tmp->minor = minor; |
| 113 | tmp->info_ent = &files[i]; |
| 114 | list_add(&tmp->list, &minor->proc_nodes.list); |
| 115 | |
| 116 | ent = proc_create_data(files[i].name, S_IRUGO, root, |
| 117 | &drm_proc_fops, tmp); |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 118 | if (!ent) { |
| 119 | DRM_ERROR("Cannot create /proc/dri/%s/%s\n", |
Marcin Slusarz | a0f9219 | 2011-10-10 19:32:17 +0200 | [diff] [blame^] | 120 | root->name, files[i].name); |
Alexey Dobriyan | 3b51096 | 2009-08-28 22:58:07 +0400 | [diff] [blame] | 121 | list_del(&tmp->list); |
Eric Anholt | 9a298b2 | 2009-03-24 12:23:04 -0700 | [diff] [blame] | 122 | kfree(tmp); |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 123 | ret = -1; |
| 124 | goto fail; |
| 125 | } |
| 126 | |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 127 | } |
| 128 | return 0; |
| 129 | |
| 130 | fail: |
| 131 | for (i = 0; i < count; i++) |
| 132 | remove_proc_entry(drm_proc_list[i].name, minor->proc_root); |
| 133 | return ret; |
| 134 | } |
| 135 | |
| 136 | /** |
| 137 | * Initialize the DRI proc filesystem for a device |
| 138 | * |
| 139 | * \param dev DRM device |
| 140 | * \param minor device minor number |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 141 | * \param root DRI proc dir entry. |
| 142 | * \param dev_root resulting DRI device proc dir entry. |
| 143 | * \return root entry pointer on success, or NULL on failure. |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 144 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 145 | * Create the DRI proc root entry "/proc/dri", the device proc root entry |
| 146 | * "/proc/dri/%minor%/", and each entry in proc_list as |
| 147 | * "/proc/dri/%minor%/%name%". |
| 148 | */ |
Dave Airlie | 2c14f28 | 2008-04-21 16:47:32 +1000 | [diff] [blame] | 149 | int drm_proc_init(struct drm_minor *minor, int minor_id, |
| 150 | struct proc_dir_entry *root) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | { |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 152 | char name[64]; |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 153 | int ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 155 | INIT_LIST_HEAD(&minor->proc_nodes.list); |
Dave Airlie | 2c14f28 | 2008-04-21 16:47:32 +1000 | [diff] [blame] | 156 | sprintf(name, "%d", minor_id); |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 157 | minor->proc_root = proc_mkdir(name, root); |
| 158 | if (!minor->proc_root) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | DRM_ERROR("Cannot create /proc/dri/%s\n", name); |
| 160 | return -1; |
| 161 | } |
| 162 | |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 163 | ret = drm_proc_create_files(drm_proc_list, DRM_PROC_ENTRIES, |
| 164 | minor->proc_root, minor); |
| 165 | if (ret) { |
| 166 | remove_proc_entry(name, root); |
| 167 | minor->proc_root = NULL; |
| 168 | DRM_ERROR("Failed to create core drm proc files\n"); |
| 169 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | } |
| 171 | |
| 172 | return 0; |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 173 | } |
Eric Anholt | 673a394 | 2008-07-30 12:06:12 -0700 | [diff] [blame] | 174 | |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 175 | int drm_proc_remove_files(struct drm_info_list *files, int count, |
| 176 | struct drm_minor *minor) |
| 177 | { |
| 178 | struct list_head *pos, *q; |
| 179 | struct drm_info_node *tmp; |
| 180 | int i; |
| 181 | |
| 182 | for (i = 0; i < count; i++) { |
| 183 | list_for_each_safe(pos, q, &minor->proc_nodes.list) { |
| 184 | tmp = list_entry(pos, struct drm_info_node, list); |
| 185 | if (tmp->info_ent == &files[i]) { |
| 186 | remove_proc_entry(files[i].name, |
| 187 | minor->proc_root); |
| 188 | list_del(pos); |
Eric Anholt | 9a298b2 | 2009-03-24 12:23:04 -0700 | [diff] [blame] | 189 | kfree(tmp); |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 190 | } |
| 191 | } |
| 192 | } |
| 193 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | } |
| 195 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | /** |
| 197 | * Cleanup the proc filesystem resources. |
| 198 | * |
| 199 | * \param minor device minor number. |
| 200 | * \param root DRI proc dir entry. |
| 201 | * \param dev_root DRI device proc dir entry. |
| 202 | * \return always zero. |
| 203 | * |
| 204 | * Remove all proc entries created by proc_init(). |
| 205 | */ |
Dave Airlie | 2c14f28 | 2008-04-21 16:47:32 +1000 | [diff] [blame] | 206 | int drm_proc_cleanup(struct drm_minor *minor, struct proc_dir_entry *root) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | char name[64]; |
| 209 | |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 210 | if (!root || !minor->proc_root) |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 211 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | |
Ben Gamari | 955b12d | 2009-02-17 20:08:49 -0500 | [diff] [blame] | 213 | drm_proc_remove_files(drm_proc_list, DRM_PROC_ENTRIES, minor); |
| 214 | |
Dave Airlie | 2c14f28 | 2008-04-21 16:47:32 +1000 | [diff] [blame] | 215 | sprintf(name, "%d", minor->index); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | remove_proc_entry(name, root); |
| 217 | |
| 218 | return 0; |
| 219 | } |
| 220 | |