| /* dristat.c -- |
| * Created: Mon Jan 15 05:05:07 2001 by faith@acm.org |
| * |
| * Copyright 2000 VA Linux Systems, Inc., Fremont, California. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| * DEALINGS IN THE SOFTWARE. |
| * |
| * Authors: Rickard E. (Rik) Faith <faith@valinux.com> |
| * |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| # include <config.h> |
| #endif |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include "xf86drm.h" |
| #include "xf86drmRandom.c" |
| #include "xf86drmHash.c" |
| #include "xf86drm.c" |
| |
| #define DRM_VERSION 0x00000001 |
| #define DRM_MEMORY 0x00000002 |
| #define DRM_CLIENTS 0x00000004 |
| #define DRM_STATS 0x00000008 |
| #define DRM_BUSID 0x00000010 |
| |
| static void getversion(int fd) |
| { |
| drmVersionPtr version; |
| |
| version = drmGetVersion(fd); |
| if (version) { |
| printf(" Version information:\n"); |
| printf(" Name: %s\n", version->name ? version->name : "?"); |
| printf(" Version: %d.%d.%d\n", |
| version->version_major, |
| version->version_minor, |
| version->version_patchlevel); |
| printf(" Date: %s\n", version->date ? version->date : "?"); |
| printf(" Desc: %s\n", version->desc ? version->desc : "?"); |
| drmFreeVersion(version); |
| } else { |
| printf(" No version information available\n"); |
| } |
| } |
| |
| static void getbusid(int fd) |
| { |
| const char *busid = drmGetBusid(fd); |
| |
| printf(" Busid: %s\n", *busid ? busid : "(not set)"); |
| drmFreeBusid(busid); |
| } |
| |
| |
| static void getvm(int fd) |
| { |
| int i; |
| const char *typename; |
| char flagname[33]; |
| drm_handle_t offset; |
| drmSize size; |
| drmMapType type; |
| drmMapFlags flags; |
| drm_handle_t handle; |
| int mtrr; |
| |
| printf(" VM map information:\n"); |
| printf(" flags: (R)estricted (r)ead/(w)rite (l)ocked (k)ernel (W)rite-combine (L)ock:\n"); |
| printf(" slot offset size type flags address mtrr\n"); |
| |
| for (i = 0; |
| !drmGetMap(fd, i, &offset, &size, &type, &flags, &handle, &mtrr); |
| i++) { |
| |
| switch (type) { |
| case DRM_FRAME_BUFFER: typename = "FB"; break; |
| case DRM_REGISTERS: typename = "REG"; break; |
| case DRM_SHM: typename = "SHM"; break; |
| case DRM_AGP: typename = "AGP"; break; |
| case DRM_SCATTER_GATHER: typename = "SG"; break; |
| default: typename = "???"; break; |
| } |
| |
| flagname[0] = (flags & DRM_RESTRICTED) ? 'R' : ' '; |
| flagname[1] = (flags & DRM_READ_ONLY) ? 'r' : 'w'; |
| flagname[2] = (flags & DRM_LOCKED) ? 'l' : ' '; |
| flagname[3] = (flags & DRM_KERNEL) ? 'k' : ' '; |
| flagname[4] = (flags & DRM_WRITE_COMBINING) ? 'W' : ' '; |
| flagname[5] = (flags & DRM_CONTAINS_LOCK) ? 'L' : ' '; |
| flagname[6] = '\0'; |
| |
| printf(" %4d 0x%08lx 0x%08lx %3.3s %6.6s 0x%08lx ", |
| i, (unsigned long)offset, (unsigned long)size, |
| typename, flagname, (unsigned long)handle); |
| if (mtrr < 0) printf("none\n"); |
| else printf("%4d\n", mtrr); |
| } |
| } |
| |
| static void getclients(int fd) |
| { |
| int i; |
| int auth; |
| int pid; |
| int uid; |
| unsigned long magic; |
| unsigned long iocs; |
| char buf[64]; |
| char cmd[40]; |
| int procfd; |
| |
| printf(" DRI client information:\n"); |
| printf(" a pid uid magic ioctls prog\n"); |
| |
| for (i = 0; !drmGetClient(fd, i, &auth, &pid, &uid, &magic, &iocs); i++) { |
| sprintf(buf, "/proc/%d/cmdline", pid); |
| memset(cmd, 0, sizeof(cmd)); |
| if ((procfd = open(buf, O_RDONLY, 0)) >= 0) { |
| read(procfd, cmd, sizeof(cmd)-1); |
| close(procfd); |
| } |
| if (*cmd) { |
| char *pt; |
| |
| for (pt = cmd; *pt; pt++) if (!isprint(*pt)) *pt = ' '; |
| printf(" %c %5d %5d %10lu %10lu %s\n", |
| auth ? 'y' : 'n', pid, uid, magic, iocs, cmd); |
| } else { |
| printf(" %c %5d %5d %10lu %10lu\n", |
| auth ? 'y' : 'n', pid, uid, magic, iocs); |
| } |
| } |
| } |
| |
| static void printhuman(unsigned long value, const char *name, int mult) |
| { |
| const char *p; |
| double f; |
| /* Print width 5 number in width 6 space */ |
| if (value < 100000) { |
| printf(" %5lu", value); |
| return; |
| } |
| |
| p = name; |
| f = (double)value / (double)mult; |
| if (f < 10.0) { |
| printf(" %4.2f%c", f, *p); |
| return; |
| } |
| |
| p++; |
| f = (double)value / (double)mult; |
| if (f < 10.0) { |
| printf(" %4.2f%c", f, *p); |
| return; |
| } |
| |
| p++; |
| f = (double)value / (double)mult; |
| if (f < 10.0) { |
| printf(" %4.2f%c", f, *p); |
| return; |
| } |
| } |
| |
| static void getstats(int fd, int i) |
| { |
| drmStatsT prev, curr; |
| int j; |
| double rate; |
| |
| printf(" System statistics:\n"); |
| |
| if (drmGetStats(fd, &prev)) return; |
| if (!i) { |
| for (j = 0; j < prev.count; j++) { |
| printf(" "); |
| printf(prev.data[j].long_format, prev.data[j].long_name); |
| if (prev.data[j].isvalue) printf(" 0x%08lx\n", prev.data[j].value); |
| else printf(" %10lu\n", prev.data[j].value); |
| } |
| return; |
| } |
| |
| printf(" "); |
| for (j = 0; j < prev.count; j++) |
| if (!prev.data[j].verbose) { |
| printf(" "); |
| printf(prev.data[j].rate_format, prev.data[j].rate_name); |
| } |
| printf("\n"); |
| |
| for (;;) { |
| sleep(i); |
| if (drmGetStats(fd, &curr)) return; |
| printf(" "); |
| for (j = 0; j < curr.count; j++) { |
| if (curr.data[j].verbose) continue; |
| if (curr.data[j].isvalue) { |
| printf(" %08lx", curr.data[j].value); |
| } else { |
| rate = (curr.data[j].value - prev.data[j].value) / (double)i; |
| printhuman(rate, curr.data[j].mult_names, curr.data[j].mult); |
| } |
| } |
| printf("\n"); |
| memcpy(&prev, &curr, sizeof(prev)); |
| } |
| |
| } |
| |
| int main(int argc, char **argv) |
| { |
| int c; |
| int mask = 0; |
| int minor = 0; |
| int interval = 0; |
| int fd; |
| char buf[64]; |
| int i; |
| |
| while ((c = getopt(argc, argv, "avmcsbM:i:")) != EOF) |
| switch (c) { |
| case 'a': mask = ~0; break; |
| case 'v': mask |= DRM_VERSION; break; |
| case 'm': mask |= DRM_MEMORY; break; |
| case 'c': mask |= DRM_CLIENTS; break; |
| case 's': mask |= DRM_STATS; break; |
| case 'b': mask |= DRM_BUSID; break; |
| case 'i': interval = strtol(optarg, NULL, 0); break; |
| case 'M': minor = strtol(optarg, NULL, 0); break; |
| default: |
| fprintf( stderr, "Usage: dristat [options]\n\n" ); |
| fprintf( stderr, "Displays DRM information. Use with no arguments to display available cards.\n\n" ); |
| fprintf( stderr, " -a Show all available information\n" ); |
| fprintf( stderr, " -b Show DRM bus ID's\n" ); |
| fprintf( stderr, " -c Display information about DRM clients\n" ); |
| fprintf( stderr, " -i [interval] Continuously display statistics every [interval] seconds\n" ); |
| fprintf( stderr, " -v Display DRM module and card version information\n" ); |
| fprintf( stderr, " -m Display memory use information\n" ); |
| fprintf( stderr, " -s Display DRM statistics\n" ); |
| fprintf( stderr, " -M [minor] Select card by minor number\n" ); |
| return 1; |
| } |
| |
| for (i = 0; i < 16; i++) if (!minor || i == minor) { |
| sprintf(buf, DRM_DEV_NAME, DRM_DIR_NAME, i); |
| fd = drmOpenMinor(i, 1, DRM_NODE_RENDER); |
| if (fd >= 0) { |
| printf("%s\n", buf); |
| if (mask & DRM_BUSID) getbusid(fd); |
| if (mask & DRM_VERSION) getversion(fd); |
| if (mask & DRM_MEMORY) getvm(fd); |
| if (mask & DRM_CLIENTS) getclients(fd); |
| if (mask & DRM_STATS) getstats(fd, interval); |
| close(fd); |
| } |
| } |
| |
| return 0; |
| } |
