?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge comment updates from DRI CVS tree.
[linux-2.6/history.git] / drivers / char / drm / drm_proc.h
blob2e607ca367300c1d9eae4e03f44f310e05128ade
1 /**
2 * \file drm_proc.h
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
40 #include "drmP.h"
41
42 static int DRM(name_info)(char *buf, char **start, off_t offset,
43 int request, int *eof, void *data);
44 static int DRM(vm_info)(char *buf, char **start, off_t offset,
45 int request, int *eof, void *data);
46 static int DRM(clients_info)(char *buf, char **start, off_t offset,
47 int request, int *eof, void *data);
48 static int DRM(queues_info)(char *buf, char **start, off_t offset,
49 int request, int *eof, void *data);
50 static int DRM(bufs_info)(char *buf, char **start, off_t offset,
51 int request, int *eof, void *data);
52 #if DRM_DEBUG_CODE
53 static int DRM(vma_info)(char *buf, char **start, off_t offset,
54 int request, int *eof, void *data);
55 #endif
56
57 /**
58 * Proc file list.
59 */
60 struct drm_proc_list {
61 const char *name; /**< file name */
62 int (*f)(char *, char **, off_t, int, int *, void *); /**< proc callback*/
63 } DRM(proc_list)[] = {
64 { "name", DRM(name_info) },
65 { "mem", DRM(mem_info) },
66 { "vm", DRM(vm_info) },
67 { "clients", DRM(clients_info) },
68 { "queues", DRM(queues_info) },
69 { "bufs", DRM(bufs_info) },
70 #if DRM_DEBUG_CODE
71 { "vma", DRM(vma_info) },
72 #endif
73 };
74 #define DRM_PROC_ENTRIES (sizeof(DRM(proc_list))/sizeof(DRM(proc_list)[0]))
75
76 /**
77 * Initialize the DRI proc filesystem for a device.
78 *
79 * \param dev DRM device.
80 * \param minor device minor number.
81 * \param root DRI proc dir entry.
82 * \param dev_root resulting DRI device proc dir entry.
83 * \return root entry pointer on success, or NULL on failure.
84 *
85 * Create the DRI proc root entry "/proc/dri", the device proc root entry
86 * "/proc/dri/%minor%/", and each entry in proc_list as
87 * "/proc/dri/%minor%/%name%".
88 */
89 struct proc_dir_entry *DRM(proc_init)(drm_device_t *dev, int minor,
90 struct proc_dir_entry *root,
91 struct proc_dir_entry **dev_root)
92 {
93 struct proc_dir_entry *ent;
94 int i, j;
95 char name[64];
96
97 if (!minor) root = create_proc_entry("dri", S_IFDIR, NULL);
98 if (!root) {
99 DRM_ERROR("Cannot create /proc/dri\n");
100 return NULL;
101 }
102
103 sprintf(name, "%d", minor);
104 *dev_root = create_proc_entry(name, S_IFDIR, root);
105 if (!*dev_root) {
106 DRM_ERROR("Cannot create /proc/dri/%s\n", name);
107 return NULL;
108 }
109
110 for (i = 0; i < DRM_PROC_ENTRIES; i++) {
111 ent = create_proc_entry(DRM(proc_list)[i].name,
112 S_IFREG|S_IRUGO, *dev_root);
113 if (!ent) {
114 DRM_ERROR("Cannot create /proc/dri/%s/%s\n",
115 name, DRM(proc_list)[i].name);
116 for (j = 0; j < i; j++)
117 remove_proc_entry(DRM(proc_list)[i].name,
118 *dev_root);
119 remove_proc_entry(name, root);
120 if (!minor) remove_proc_entry("dri", NULL);
121 return NULL;
122 }
123 ent->read_proc = DRM(proc_list)[i].f;
124 ent->data = dev;
125 }
126
127 return root;
128 }
129
130
131 /**
132 * Cleanup the proc filesystem resources.
133 *
134 * \param minor device minor number.
135 * \param root DRI proc dir entry.
136 * \param dev_root DRI device proc dir entry.
137 * \return always zero.
138 *
139 * Remove all proc entries created by proc_init().
140 */
141 int DRM(proc_cleanup)(int minor, struct proc_dir_entry *root,
142 struct proc_dir_entry *dev_root)
143 {
144 int i;
145 char name[64];
146
147 if (!root || !dev_root) return 0;
148
149 for (i = 0; i < DRM_PROC_ENTRIES; i++)
150 remove_proc_entry(DRM(proc_list)[i].name, dev_root);
151 sprintf(name, "%d", minor);
152 remove_proc_entry(name, root);
153 if (!minor) remove_proc_entry("dri", NULL);
154
155 return 0;
156 }
157
158 /**
159 * Called when "/proc/dri/.../name" is read.
160 *
161 * \param buf output buffer.
162 * \param start start of output data.
163 * \param offset requested start offset.
164 * \param request requested number of bytes.
165 * \param eof whether there is no more data to return.
166 * \param data private data.
167 * \return number of written bytes.
168 *
169 * Prints the device name together with the bus id if available.
170 */
171 static int DRM(name_info)(char *buf, char **start, off_t offset, int request,
172 int *eof, void *data)
173 {
174 drm_device_t *dev = (drm_device_t *)data;
175 int len = 0;
176
177 if (offset > DRM_PROC_LIMIT) {
178 *eof = 1;
179 return 0;
180 }
181
182 *start = &buf[offset];
183 *eof = 0;
184
185 if (dev->unique) {
186 DRM_PROC_PRINT("%s 0x%lx %s\n",
187 dev->name, (long)dev->device, dev->unique);
188 } else {
189 DRM_PROC_PRINT("%s 0x%lx\n", dev->name, (long)dev->device);
190 }
191
192 if (len > request + offset) return request;
193 *eof = 1;
194 return len - offset;
195 }
196
197 /**
198 * Called when "/proc/dri/.../vm" is read.
199 *
200 * \param buf output buffer.
201 * \param start start of output data.
202 * \param offset requested start offset.
203 * \param request requested number of bytes.
204 * \param eof whether there is no more data to return.
205 * \param data private data.
206 * \return number of written bytes.
207 *
208 * Prints information about all mappings in drm_device::maplist.
209 */
210 static int DRM(_vm_info)(char *buf, char **start, off_t offset, int request,
211 int *eof, void *data)
212 {
213 drm_device_t *dev = (drm_device_t *)data;
214 int len = 0;
215 drm_map_t *map;
216 drm_map_list_t *r_list;
217 struct list_head *list;
218
219 /* Hardcoded from _DRM_FRAME_BUFFER,
220 _DRM_REGISTERS, _DRM_SHM, _DRM_AGP, and
221 _DRM_SCATTER_GATHER. */
222 const char *types[] = { "FB", "REG", "SHM", "AGP", "SG" };
223 const char *type;
224 int i;
225
226 if (offset > DRM_PROC_LIMIT) {
227 *eof = 1;
228 return 0;
229 }
230
231 *start = &buf[offset];
232 *eof = 0;
233
234 DRM_PROC_PRINT("slot offset size type flags "
235 "address mtrr\n\n");
236 i = 0;
237 if (dev->maplist != NULL) list_for_each(list, &dev->maplist->head) {
238 r_list = list_entry(list, drm_map_list_t, head);
239 map = r_list->map;
240 if(!map) continue;
241 if (map->type < 0 || map->type > 4) type = "??";
242 else type = types[map->type];
243 DRM_PROC_PRINT("%4d 0x%08lx 0x%08lx %4.4s 0x%02x 0x%08lx ",
244 i,
245 map->offset,
246 map->size,
247 type,
248 map->flags,
249 (unsigned long)map->handle);
250 if (map->mtrr < 0) {
251 DRM_PROC_PRINT("none\n");
252 } else {
253 DRM_PROC_PRINT("%4d\n", map->mtrr);
254 }
255 i++;
256 }
257
258 if (len > request + offset) return request;
259 *eof = 1;
260 return len - offset;
261 }
262
263 /**
264 * Simply calls _vm_info() while holding the drm_device::struct_sem lock.
265 */
266 static int DRM(vm_info)(char *buf, char **start, off_t offset, int request,
267 int *eof, void *data)
268 {
269 drm_device_t *dev = (drm_device_t *)data;
270 int ret;
271
272 down(&dev->struct_sem);
273 ret = DRM(_vm_info)(buf, start, offset, request, eof, data);
274 up(&dev->struct_sem);
275 return ret;
276 }
277
278 /**
279 * Called when "/proc/dri/.../queues" is read.
280 *
281 * \param buf output buffer.
282 * \param start start of output data.
283 * \param offset requested start offset.
284 * \param request requested number of bytes.
285 * \param eof whether there is no more data to return.
286 * \param data private data.
287 * \return number of written bytes.
288 */
289 static int DRM(_queues_info)(char *buf, char **start, off_t offset,
290 int request, int *eof, void *data)
291 {
292 drm_device_t *dev = (drm_device_t *)data;
293 int len = 0;
294 int i;
295 drm_queue_t *q;
296
297 if (offset > DRM_PROC_LIMIT) {
298 *eof = 1;
299 return 0;
300 }
301
302 *start = &buf[offset];
303 *eof = 0;
304
305 DRM_PROC_PRINT(" ctx/flags use fin"
306 " blk/rw/rwf wait flushed queued"
307 " locks\n\n");
308 for (i = 0; i < dev->queue_count; i++) {
309 q = dev->queuelist[i];
310 atomic_inc(&q->use_count);
311 DRM_PROC_PRINT_RET(atomic_dec(&q->use_count),
312 "%5d/0x%03x %5d %5d"
313 " %5d/%c%c/%c%c%c %5Zd\n",
314 i,
315 q->flags,
316 atomic_read(&q->use_count),
317 atomic_read(&q->finalization),
318 atomic_read(&q->block_count),
319 atomic_read(&q->block_read) ? 'r' : '-',
320 atomic_read(&q->block_write) ? 'w' : '-',
321 waitqueue_active(&q->read_queue) ? 'r':'-',
322 waitqueue_active(&q->write_queue) ? 'w':'-',
323 waitqueue_active(&q->flush_queue) ? 'f':'-',
324 DRM_BUFCOUNT(&q->waitlist));
325 atomic_dec(&q->use_count);
326 }
327
328 if (len > request + offset) return request;
329 *eof = 1;
330 return len - offset;
331 }
332
333 /**
334 * Simply calls _queues_info() while holding the drm_device::struct_sem lock.
335 */
336 static int DRM(queues_info)(char *buf, char **start, off_t offset, int request,
337 int *eof, void *data)
338 {
339 drm_device_t *dev = (drm_device_t *)data;
340 int ret;
341
342 down(&dev->struct_sem);
343 ret = DRM(_queues_info)(buf, start, offset, request, eof, data);
344 up(&dev->struct_sem);
345 return ret;
346 }
347
348 /**
349 * Called when "/proc/dri/.../bufs" is read.
350 *
351 * \param buf output buffer.
352 * \param start start of output data.
353 * \param offset requested start offset.
354 * \param request requested number of bytes.
355 * \param eof whether there is no more data to return.
356 * \param data private data.
357 * \return number of written bytes.
358 */
359 static int DRM(_bufs_info)(char *buf, char **start, off_t offset, int request,
360 int *eof, void *data)
361 {
362 drm_device_t *dev = (drm_device_t *)data;
363 int len = 0;
364 drm_device_dma_t *dma = dev->dma;
365 int i;
366
367 if (!dma || offset > DRM_PROC_LIMIT) {
368 *eof = 1;
369 return 0;
370 }
371
372 *start = &buf[offset];
373 *eof = 0;
374
375 DRM_PROC_PRINT(" o size count free segs pages kB\n\n");
376 for (i = 0; i <= DRM_MAX_ORDER; i++) {
377 if (dma->bufs[i].buf_count)
378 DRM_PROC_PRINT("%2d %8d %5d %5d %5d %5d %5ld\n",
379 i,
380 dma->bufs[i].buf_size,
381 dma->bufs[i].buf_count,
382 atomic_read(&dma->bufs[i]
383 .freelist.count),
384 dma->bufs[i].seg_count,
385 dma->bufs[i].seg_count
386 *(1 << dma->bufs[i].page_order),
387 (dma->bufs[i].seg_count
388 * (1 << dma->bufs[i].page_order))
389 * PAGE_SIZE / 1024);
390 }
391 DRM_PROC_PRINT("\n");
392 for (i = 0; i < dma->buf_count; i++) {
393 if (i && !(i%32)) DRM_PROC_PRINT("\n");
394 DRM_PROC_PRINT(" %d", dma->buflist[i]->list);
395 }
396 DRM_PROC_PRINT("\n");
397
398 if (len > request + offset) return request;
399 *eof = 1;
400 return len - offset;
401 }
402
403 /**
404 * Simply calls _bufs_info() while holding the drm_device::struct_sem lock.
405 */
406 static int DRM(bufs_info)(char *buf, char **start, off_t offset, int request,
407 int *eof, void *data)
408 {
409 drm_device_t *dev = (drm_device_t *)data;
410 int ret;
411
412 down(&dev->struct_sem);
413 ret = DRM(_bufs_info)(buf, start, offset, request, eof, data);
414 up(&dev->struct_sem);
415 return ret;
416 }
417
418 /**
419 * Called when "/proc/dri/.../clients" is read.
420 *
421 * \param buf output buffer.
422 * \param start start of output data.
423 * \param offset requested start offset.
424 * \param request requested number of bytes.
425 * \param eof whether there is no more data to return.
426 * \param data private data.
427 * \return number of written bytes.
428 */
429 static int DRM(_clients_info)(char *buf, char **start, off_t offset,
430 int request, int *eof, void *data)
431 {
432 drm_device_t *dev = (drm_device_t *)data;
433 int len = 0;
434 drm_file_t *priv;
435
436 if (offset > DRM_PROC_LIMIT) {
437 *eof = 1;
438 return 0;
439 }
440
441 *start = &buf[offset];
442 *eof = 0;
443
444 DRM_PROC_PRINT("a dev pid uid magic ioctls\n\n");
445 for (priv = dev->file_first; priv; priv = priv->next) {
446 DRM_PROC_PRINT("%c %3d %5d %5d %10u %10lu\n",
447 priv->authenticated ? 'y' : 'n',
448 priv->minor,
449 priv->pid,
450 priv->uid,
451 priv->magic,
452 priv->ioctl_count);
453 }
454
455 if (len > request + offset) return request;
456 *eof = 1;
457 return len - offset;
458 }
459
460 /**
461 * Simply calls _clients_info() while holding the drm_device::struct_sem lock.
462 */
463 static int DRM(clients_info)(char *buf, char **start, off_t offset,
464 int request, int *eof, void *data)
465 {
466 drm_device_t *dev = (drm_device_t *)data;
467 int ret;
468
469 down(&dev->struct_sem);
470 ret = DRM(_clients_info)(buf, start, offset, request, eof, data);
471 up(&dev->struct_sem);
472 return ret;
473 }
474
475 #if DRM_DEBUG_CODE
476
477 static int DRM(_vma_info)(char *buf, char **start, off_t offset, int request,
478 int *eof, void *data)
479 {
480 drm_device_t *dev = (drm_device_t *)data;
481 int len = 0;
482 drm_vma_entry_t *pt;
483 struct vm_area_struct *vma;
484 #if defined(__i386__)
485 unsigned int pgprot;
486 #endif
487
488 if (offset > DRM_PROC_LIMIT) {
489 *eof = 1;
490 return 0;
491 }
492
493 *start = &buf[offset];
494 *eof = 0;
495
496 DRM_PROC_PRINT("vma use count: %d, high_memory = %p, 0x%08lx\n",
497 atomic_read(&dev->vma_count),
498 high_memory, virt_to_phys(high_memory));
499 for (pt = dev->vmalist; pt; pt = pt->next) {
500 if (!(vma = pt->vma)) continue;
501 DRM_PROC_PRINT("\n%5d 0x%08lx-0x%08lx %c%c%c%c%c%c 0x%08lx",
502 pt->pid,
503 vma->vm_start,
504 vma->vm_end,
505 vma->vm_flags & VM_READ ? 'r' : '-',
506 vma->vm_flags & VM_WRITE ? 'w' : '-',
507 vma->vm_flags & VM_EXEC ? 'x' : '-',
508 vma->vm_flags & VM_MAYSHARE ? 's' : 'p',
509 vma->vm_flags & VM_LOCKED ? 'l' : '-',
510 vma->vm_flags & VM_IO ? 'i' : '-',
511 VM_OFFSET(vma));
512
513 #if defined(__i386__)
514 pgprot = pgprot_val(vma->vm_page_prot);
515 DRM_PROC_PRINT(" %c%c%c%c%c%c%c%c%c",
516 pgprot & _PAGE_PRESENT ? 'p' : '-',
517 pgprot & _PAGE_RW ? 'w' : 'r',
518 pgprot & _PAGE_USER ? 'u' : 's',
519 pgprot & _PAGE_PWT ? 't' : 'b',
520 pgprot & _PAGE_PCD ? 'u' : 'c',
521 pgprot & _PAGE_ACCESSED ? 'a' : '-',
522 pgprot & _PAGE_DIRTY ? 'd' : '-',
523 pgprot & _PAGE_PSE ? 'm' : 'k',
524 pgprot & _PAGE_GLOBAL ? 'g' : 'l' );
525 #endif
526 DRM_PROC_PRINT("\n");
527 }
528
529 if (len > request + offset) return request;
530 *eof = 1;
531 return len - offset;
532 }
533
534 static int DRM(vma_info)(char *buf, char **start, off_t offset, int request,
535 int *eof, void *data)
536 {
537 drm_device_t *dev = (drm_device_t *)data;
538 int ret;
539
540 down(&dev->struct_sem);
541 ret = DRM(_vma_info)(buf, start, offset, request, eof, data);
542 up(&dev->struct_sem);
543 return ret;
544 }
545 #endif
546
547
Historical 2.5/2.6 development