tests/dristat.c

   1 /* dristat.c --
   2  * Created: Mon Jan 15 05:05:07 2001 by faith@acm.org
   3  *
   4  * Copyright 2000 VA Linux Systems, Inc., Fremont, California.
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the next
  15  * paragraph) shall be included in all copies or substantial portions of the
  16  * Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  22  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  23  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24  * DEALINGS IN THE SOFTWARE.
  25  *
  26  * Authors: Rickard E. (Rik) Faith <faith@valinux.com>
  27  *
  28  */
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <unistd.h>
  33 #include "../../../xf86drm.h"
  34 #include "../xf86drmRandom.c"
  35 #include "../xf86drmHash.c"
  36 #include "../xf86drm.c"
  37
  38 #define DRM_VERSION 0x00000001
  39 #define DRM_MEMORY  0x00000002
  40 #define DRM_CLIENTS 0x00000004
  41 #define DRM_STATS   0x00000008
  42 #define DRM_BUSID   0x00000010
  43
  44 static void getversion(int fd)
  45 {
  46     drmVersionPtr version;
  47
  48     version = drmGetVersion(fd);
  49     if (version) {
  50         printf("  Version information:\n");
  51         printf("    Name: %s\n", version->name ? version->name : "?");
  52         printf("    Version: %d.%d.%d\n",
  53                version->version_major,
  54                version->version_minor,
  55                version->version_patchlevel);
  56         printf("    Date: %s\n", version->date ? version->date : "?");
  57         printf("    Desc: %s\n", version->desc ? version->desc : "?");
  58         drmFreeVersion(version);
  59     } else {
  60         printf("  No version information available\n");
  61     }
  62 }
  63
  64 static void getbusid(int fd)
  65 {
  66     const char *busid = drmGetBusid(fd);
  67
  68     printf("  Busid: %s\n", *busid ? busid : "(not set)");
  69     drmFreeBusid(busid);
  70 }
  71
  72 #if 0
  73 typedef struct {
  74     unsigned long       offset;  /* Requested physical address (0 for SAREA)*/
  75     unsigned long       size;    /* Requested physical size (bytes)         */
  76     drm_map_type_t      type;    /* Type of memory to map                   */
  77     drm_map_flags_t flags;       /* Flags                                   */
  78     void                *handle; /* User-space: "Handle" to pass to mmap    */
  79     /* Kernel-space: kernel-virtual address    */
  80     int         mtrr;    /* MTRR slot used                          */
  81                                  /* Private data                            */
  82 } drmVmRec, *drmVmPtr;
  83 #endif
  84
  85 static void getvm(int fd)
  86 {
  87     int             i;
  88     const char      *typename;
  89     char            flagname[33];
  90     drmHandle       offset;
  91     drmSize         size;
  92     drmMapType      type;
  93     drmMapFlags     flags;
  94     drmHandle       handle;
  95     int             mtrr;
  96
  97     printf("  VM map information (Restricted locked kernel WC Lock):\n");
  98     printf("    slot     offset       size type flags    address mtrr\n");
  99
 100     for (i = 0;
 101          !drmGetMap(fd, i, &offset, &size, &type, &flags, &handle, &mtrr);
 102          i++) {
 103
 104         switch (type) {
 105         case DRM_FRAME_BUFFER: typename = "FB";  break;
 106         case DRM_REGISTERS:    typename = "REG"; break;
 107         case DRM_SHM:          typename = "SHM"; break;
 108         case DRM_AGP:          typename = "AGP"; break;
 109         default:               typename = "???"; break;
 110         }
 111
 112         flagname[0] = (flags & DRM_RESTRICTED)      ? 'R' : ' ';
 113         flagname[1] = (flags & DRM_READ_ONLY)       ? 'r' : 'w';
 114         flagname[2] = (flags & DRM_LOCKED)          ? 'l' : ' ';
 115         flagname[3] = (flags & DRM_KERNEL)          ? 'k' : ' ';
 116         flagname[4] = (flags & DRM_WRITE_COMBINING) ? 'W' : ' ';
 117         flagname[5] = (flags & DRM_CONTAINS_LOCK)   ? 'L' : ' ';
 118         flagname[6] = '\0';
 119
 120         printf("    %4d 0x%08lx 0x%08lx %3.3s %6.6s 0x%08lx ",
 121                i, offset, (unsigned long)size, typename, flagname, handle);
 122         if (mtrr < 0) printf("none\n");
 123         else          printf("%4d\n", mtrr);
 124     }
 125 }
 126
 127 static void getclients(int fd)
 128 {
 129     int           i;
 130     int           auth;
 131     int           pid;
 132     int           uid;
 133     unsigned long magic;
 134     unsigned long iocs;
 135     char          buf[64];
 136     char          cmd[40];
 137     int           procfd;
 138
 139     printf("  DRI client information:\n");
 140     printf("    a   pid   uid      magic     ioctls   prog\n");
 141
 142     for (i = 0; !drmGetClient(fd, i, &auth, &pid, &uid, &magic, &iocs); i++) {
 143         sprintf(buf, "/proc/%d/cmdline", pid);
 144         memset(cmd, sizeof(cmd), 0);
 145         if ((procfd = open(buf, O_RDONLY, 0)) >= 0) {
 146             read(procfd, cmd, sizeof(cmd)-1);
 147             close(procfd);
 148         }
 149         if (*cmd) {
 150             char *pt;
 151
 152             for (pt = cmd; *pt; pt++) if (!isprint(*pt)) *pt = ' ';
 153             printf("    %c %5d %5d %10lu %10lu   %s\n",
 154                    auth ? 'y' : 'n', pid, uid, magic, iocs, cmd);
 155         } else {
 156             printf("    %c %5d %5d %10lu %10lu\n",
 157                    auth ? 'y' : 'n', pid, uid, magic, iocs);
 158         }
 159     }
 160 }
 161
 162 static void printhuman(unsigned long value, const char *name, int mult)
 163 {
 164     const char *p;
 165     double     f;
 166                                 /* Print width 5 number in width 6 space */
 167     if (value < 100000) {
 168         printf(" %5lu", value);
 169         return;
 170     }
 171
 172     p = name;
 173     f = (double)value / (double)mult;
 174     if (f < 10.0) {
 175         printf(" %4.2f%c", f, *p);
 176         return;
 177     }
 178
 179     p++;
 180     f = (double)value / (double)mult;
 181     if (f < 10.0) {
 182         printf(" %4.2f%c", f, *p);
 183         return;
 184     }
 185
 186     p++;
 187     f = (double)value / (double)mult;
 188     if (f < 10.0) {
 189         printf(" %4.2f%c", f, *p);
 190         return;
 191     }
 192 }
 193
 194 static void getstats(int fd, int i)
 195 {
 196     drmStatsT prev, curr;
 197     int       j;
 198     double    rate;
 199
 200     printf("  System statistics:\n");
 201
 202     if (drmGetStats(fd, &prev)) return;
 203     if (!i) {
 204         for (j = 0; j < prev.count; j++) {
 205             printf("    ");
 206             printf(prev.data[j].long_format, prev.data[j].long_name);
 207             if (prev.data[j].isvalue) printf(" 0x%08lx\n", prev.data[j].value);
 208             else                      printf(" %10lu\n", prev.data[j].value);
 209         }
 210         return;
 211     }
 212
 213     printf("    ");
 214     for (j = 0; j < prev.count; j++)
 215         if (!prev.data[j].verbose) {
 216             printf(" ");
 217             printf(prev.data[j].rate_format, prev.data[j].rate_name);
 218         }
 219     printf("\n");
 220
 221     for (;;) {
 222         sleep(i);
 223         if (drmGetStats(fd, &curr)) return;
 224         printf("    ");
 225         for (j = 0; j < curr.count; j++) {
 226             if (curr.data[j].verbose) continue;
 227             if (curr.data[j].isvalue) {
 228                 printf(" %08lx", curr.data[j].value);
 229             } else {
 230                 rate = (curr.data[j].value - prev.data[j].value) / (double)i;
 231                 printhuman(rate, curr.data[j].mult_names, curr.data[j].mult);
 232             }
 233         }
 234         printf("\n");
 235         memcpy(&prev, &curr, sizeof(prev));
 236     }
 237
 238 }
 239
 240 int main(int argc, char **argv)
 241 {
 242     int  c;
 243     int  mask     = 0;
 244     int  minor    = 0;
 245     int  interval = 0;
 246     int  fd;
 247     char buf[64];
 248     int  i;
 249
 250     while ((c = getopt(argc, argv, "avmcsbM:i:")) != EOF)
 251         switch (c) {
 252         case 'a': mask = ~0;                          break;
 253         case 'v': mask |= DRM_VERSION;                break;
 254         case 'm': mask |= DRM_MEMORY;                 break;
 255         case 'c': mask |= DRM_CLIENTS;                break;
 256         case 's': mask |= DRM_STATS;                  break;
 257         case 'b': mask |= DRM_BUSID;                  break;
 258         case 'i': interval = strtol(optarg, NULL, 0); break;
 259         case 'M': minor = strtol(optarg, NULL, 0);    break;
 260         default:
 261             fprintf( stderr, "Usage: dristat [options]\n" );
 262             return 1;
 263         }
 264
 265     for (i = 0; i < 16; i++) if (!minor || i == minor) {
 266         sprintf(buf, DRM_DEV_NAME, DRM_DIR_NAME, i);
 267         fd = drmOpenMinor(i, 1);
 268         if (fd >= 0) {
 269             printf("%s\n", buf);
 270             if (mask & DRM_BUSID)   getbusid(fd);
 271             if (mask & DRM_VERSION) getversion(fd);
 272             if (mask & DRM_MEMORY)  getvm(fd);
 273             if (mask & DRM_CLIENTS) getclients(fd);
 274             if (mask & DRM_STATS)   getstats(fd, interval);
 275             close(fd);
 276         }
 277     }
 278
 279     return 0;
 280 }