bsd-core/drm_sysctl.c

   1 /*
   2  * Copyright 2003 Eric Anholt
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #ifdef __FreeBSD__
  26
  27 #include <sys/sysctl.h>
  28
  29 static int         DRM(name_info)DRM_SYSCTL_HANDLER_ARGS;
  30 static int         DRM(vm_info)DRM_SYSCTL_HANDLER_ARGS;
  31 static int         DRM(clients_info)DRM_SYSCTL_HANDLER_ARGS;
  32 static int         DRM(bufs_info)DRM_SYSCTL_HANDLER_ARGS;
  33
  34 struct DRM(sysctl_list) {
  35         const char *name;
  36         int        (*f) DRM_SYSCTL_HANDLER_ARGS;
  37 } DRM(sysctl_list)[] = {
  38         { "name",    DRM(name_info)    },
  39 #ifdef DEBUG_MEMORY
  40         { "mem",     DRM(mem_info)     },
  41 #endif
  42         { "vm",      DRM(vm_info)      },
  43         { "clients", DRM(clients_info) },
  44         { "bufs",    DRM(bufs_info)    },
  45 };
  46 #define DRM_SYSCTL_ENTRIES (sizeof(DRM(sysctl_list))/sizeof(DRM(sysctl_list)[0]))
  47
  48 struct drm_sysctl_info {
  49         struct sysctl_ctx_list ctx;
  50         char                   name[2];
  51 };
  52
  53 int DRM(sysctl_init)(drm_device_t *dev)
  54 {
  55         struct drm_sysctl_info *info;
  56         struct sysctl_oid *oid;
  57         struct sysctl_oid *top, *drioid;
  58         int               i;
  59
  60         info = DRM(alloc)(sizeof *info, DRM_MEM_DRIVER);
  61         if ( !info )
  62                 return 1;
  63         bzero(info, sizeof *info);
  64         dev->sysctl = info;
  65
  66         /* Add the sysctl node for DRI if it doesn't already exist */
  67         drioid = SYSCTL_ADD_NODE( &info->ctx, &sysctl__hw_children, OID_AUTO, "dri", CTLFLAG_RW, NULL, "DRI Graphics");
  68         if (!drioid)
  69                 return 1;
  70
  71         /* Find the next free slot under hw.dri */
  72         i = 0;
  73         SLIST_FOREACH(oid, SYSCTL_CHILDREN(drioid), oid_link) {
  74                 if (i <= oid->oid_arg2)
  75                         i = oid->oid_arg2 + 1;
  76         }
  77         if (i>9)
  78                 return 1;
  79
  80         /* Add the hw.dri.x for our device */
  81         info->name[0] = '0' + i;
  82         info->name[1] = 0;
  83         top = SYSCTL_ADD_NODE( &info->ctx, SYSCTL_CHILDREN(drioid), OID_AUTO, info->name, CTLFLAG_RW, NULL, NULL);
  84         if (!top)
  85                 return 1;
  86
  87         for (i = 0; i < DRM_SYSCTL_ENTRIES; i++) {
  88                 oid = sysctl_add_oid( &info->ctx,
  89                         SYSCTL_CHILDREN(top),
  90                         OID_AUTO,
  91                         DRM(sysctl_list)[i].name,
  92                         CTLTYPE_INT | CTLFLAG_RD,
  93                         dev,
  94                         0,
  95                         DRM(sysctl_list)[i].f,
  96                         "A",
  97                         NULL);
  98                 if (!oid)
  99                         return 1;
 100         }
 101         return 0;
 102 }
 103
 104 int DRM(sysctl_cleanup)(drm_device_t *dev)
 105 {
 106         int error;
 107         error = sysctl_ctx_free( &dev->sysctl->ctx );
 108
 109         DRM(free)(dev->sysctl, sizeof *dev->sysctl, DRM_MEM_DRIVER);
 110         dev->sysctl = NULL;
 111
 112         return error;
 113 }
 114
 115 static int DRM(name_info)DRM_SYSCTL_HANDLER_ARGS
 116 {
 117         drm_device_t *dev = arg1;
 118         char buf[128];
 119         int error;
 120
 121         if (dev->unique) {
 122                 DRM_SYSCTL_PRINT("%s 0x%x %s",
 123                                dev->name, dev2udev(dev->devnode), dev->unique);
 124         } else {
 125                 DRM_SYSCTL_PRINT("%s 0x%x", dev->name, dev2udev(dev->devnode));
 126         }
 127
 128         SYSCTL_OUT(req, "", 1);
 129
 130         return 0;
 131 }
 132
 133 static int DRM(_vm_info)DRM_SYSCTL_HANDLER_ARGS
 134 {
 135         drm_device_t *dev = arg1;
 136         drm_local_map_t    *map;
 137         drm_map_list_entry_t    *listentry;
 138         const char   *types[] = { "FB", "REG", "SHM", "AGP", "SG" };
 139         const char   *type;
 140         int          i=0;
 141         char         buf[128];
 142         int          error;
 143
 144         DRM_SYSCTL_PRINT("\nslot         offset       size type flags    "
 145                          "address mtrr\n");
 146
 147         if (dev->maplist != NULL) {
 148                 TAILQ_FOREACH(listentry, dev->maplist, link) {
 149                         map = listentry->map;
 150                         if (map->type < 0 || map->type > 4)
 151                                 type = "??";
 152                         else
 153                                 type = types[map->type];
 154                         DRM_SYSCTL_PRINT("%4d 0x%08lx 0x%08lx %4.4s  0x%02x 0x%08lx ",
 155                                          i,
 156                                          map->offset,
 157                                          map->size,
 158                                          type,
 159                                          map->flags,
 160                                          (unsigned long)map->handle);
 161                         if (map->mtrr < 0) {
 162                                 DRM_SYSCTL_PRINT("no\n");
 163                         } else {
 164                                 DRM_SYSCTL_PRINT("yes\n");
 165                         }
 166                         i++;
 167                 }
 168         }
 169         SYSCTL_OUT(req, "", 1);
 170
 171         return 0;
 172 }
 173
 174 static int DRM(vm_info)DRM_SYSCTL_HANDLER_ARGS
 175 {
 176         drm_device_t *dev = arg1;
 177         int          ret;
 178
 179         DRM_LOCK();
 180         ret = DRM(_vm_info)(oidp, arg1, arg2, req);
 181         DRM_UNLOCK();
 182
 183         return ret;
 184 }
 185
 186
 187 /* drm_bufs_info is called whenever a process reads
 188    hw.dri.0.bufs. */
 189
 190 static int DRM(_bufs_info) DRM_SYSCTL_HANDLER_ARGS
 191 {
 192         drm_device_t     *dev = arg1;
 193         drm_device_dma_t *dma = dev->dma;
 194         int              i;
 195         char             buf[128];
 196         int              error;
 197
 198         if (!dma)       return 0;
 199         DRM_SYSCTL_PRINT("\n o     size count  free      segs pages    kB\n");
 200         for (i = 0; i <= DRM_MAX_ORDER; i++) {
 201                 if (dma->bufs[i].buf_count)
 202                         DRM_SYSCTL_PRINT("%2d %8d %5d %5d %5d %5d %5d\n",
 203                                        i,
 204                                        dma->bufs[i].buf_size,
 205                                        dma->bufs[i].buf_count,
 206                                        atomic_read(&dma->bufs[i]
 207                                                    .freelist.count),
 208                                        dma->bufs[i].seg_count,
 209                                        dma->bufs[i].seg_count
 210                                        *(1 << dma->bufs[i].page_order),
 211                                        (dma->bufs[i].seg_count
 212                                         * (1 << dma->bufs[i].page_order))
 213                                        * PAGE_SIZE / 1024);
 214         }
 215         DRM_SYSCTL_PRINT("\n");
 216         for (i = 0; i < dma->buf_count; i++) {
 217                 if (i && !(i%32)) DRM_SYSCTL_PRINT("\n");
 218                 DRM_SYSCTL_PRINT(" %d", dma->buflist[i]->list);
 219         }
 220         DRM_SYSCTL_PRINT("\n");
 221
 222         SYSCTL_OUT(req, "", 1);
 223         return 0;
 224 }
 225
 226 static int DRM(bufs_info) DRM_SYSCTL_HANDLER_ARGS
 227 {
 228         drm_device_t *dev = arg1;
 229         int          ret;
 230
 231         DRM_LOCK();
 232         ret = DRM(_bufs_info)(oidp, arg1, arg2, req);
 233         DRM_UNLOCK();
 234         return ret;
 235 }
 236
 237
 238 static int DRM(_clients_info) DRM_SYSCTL_HANDLER_ARGS
 239 {
 240         drm_device_t *dev = arg1;
 241         drm_file_t   *priv;
 242         char         buf[128];
 243         int          error;
 244
 245         DRM_SYSCTL_PRINT("\na dev       pid    uid      magic     ioctls\n");
 246         TAILQ_FOREACH(priv, &dev->files, link) {
 247                 DRM_SYSCTL_PRINT("%c %3d %5d %5d %10u %10lu\n",
 248                                priv->authenticated ? 'y' : 'n',
 249                                priv->minor,
 250                                priv->pid,
 251                                priv->uid,
 252                                priv->magic,
 253                                priv->ioctl_count);
 254         }
 255
 256         SYSCTL_OUT(req, "", 1);
 257         return 0;
 258 }
 259
 260 static int DRM(clients_info)DRM_SYSCTL_HANDLER_ARGS
 261 {
 262         drm_device_t *dev = arg1;
 263         int          ret;
 264
 265         DRM_LOCK();
 266         ret = DRM(_clients_info)(oidp, arg1, arg2, req);
 267         DRM_UNLOCK();
 268         return ret;
 269 }
 270
 271
 272 #elif defined(__NetBSD__)
 273 /* stub it out for now, sysctl is only for debugging */
 274 int DRM(sysctl_init)(drm_device_t *dev)
 275 {
 276         return 0;
 277 }
 278
 279 int DRM(sysctl_cleanup)(drm_device_t *dev)
 280 {
 281         return 0;
 282 }
 283 #endif