usr.sbin/memcontrol/memcontrol.c

   1 /*-
   2  * Copyright (c) 1999 Michael Smith <msmith@freebsd.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/usr.sbin/memcontrol/memcontrol.c,v 1.3.4.5 2002/09/16 21:58:41 dwmalone Exp $
  27  * $DragonFly: src/usr.sbin/memcontrol/memcontrol.c,v 1.3 2005/03/18 01:57:58 cpressey Exp $
  28  */
  29
  30 #include <sys/types.h>
  31 #include <sys/ioctl.h>
  32 #include <sys/memrange.h>
  33
  34 #include <err.h>
  35 #include <fcntl.h>
  36 #include <paths.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41
  42 struct
  43 {
  44     const char  *name;
  45     int         val;
  46     int         kind;
  47 #define MDF_SETTABLE    (1<<0)
  48 } attrnames[] = {
  49     {"uncacheable",     MDF_UNCACHEABLE,        MDF_SETTABLE},
  50     {"write-combine",   MDF_WRITECOMBINE,       MDF_SETTABLE},
  51     {"write-through",   MDF_WRITETHROUGH,       MDF_SETTABLE},
  52     {"write-back",      MDF_WRITEBACK,          MDF_SETTABLE},
  53     {"write-protect",   MDF_WRITEPROTECT,       MDF_SETTABLE},
  54     {"force",           MDF_FORCE,              MDF_SETTABLE},
  55     {"unknown",         MDF_UNKNOWN,            0},
  56     {"fixed-base",      MDF_FIXBASE,            0},
  57     {"fixed-length",    MDF_FIXLEN,             0},
  58     {"set-by-firmware", MDF_FIRMWARE,           0},
  59     {"active",          MDF_ACTIVE,             MDF_SETTABLE},
  60     {"bogus",           MDF_BOGUS,              0},
  61     {NULL,              0,                      0}
  62 };
  63
  64 static void     listfunc(int memfd, int argc, char *argv[]);
  65 static void     setfunc(int memfd, int argc, char *argv[]);
  66 static void     clearfunc(int memfd, int argc, char *argv[]);
  67 static void     helpfunc(int memfd, int argc, char *argv[]);
  68 static void     help(const char *what);
  69
  70 struct
  71 {
  72     const char  *cmd;
  73     const char  *desc;
  74     void        (*func)(int memfd, int argc, char *argv[]);
  75 } functions[] = {
  76     {"list",
  77      "List current memory range attributes\n"
  78      "    list [-a]\n"
  79      "        -a    list all range slots, even those that are inactive",
  80      listfunc},
  81     {"set",
  82      "Set memory range attributes\n"
  83      "    set -b <base> -l <length> -o <owner> <attribute>\n"
  84      "        <base>      memory range base address\n"
  85      "        <length>    length of memory range in bytes, power of 2\n"
  86      "        <owner>     text identifier for this setting (7 char max)\n"
  87      "        <attribute> attribute(s) to be applied to this range:\n"
  88      "                        uncacheable\n"
  89      "                        write-combine\n"
  90      "                        write-through\n"
  91      "                        write-back\n"
  92      "                        write-protect",
  93      setfunc},
  94     {"clear",
  95      "Clear memory range attributes\n"
  96      "    clear -o <owner>\n"
  97      "        <owner>     all ranges with this owner will be cleared\n"
  98      "    clear -b <base> -l <length>\n"
  99      "        <base>      memory range base address\n"
 100      "        <length>    length of memory range in bytes, power of 2\n"
 101      "                    Base and length must exactly match an existing range",
 102      clearfunc},
 103     {NULL,      NULL,                                   helpfunc}
 104 };
 105
 106 int
 107 main(int argc, char *argv[])
 108 {
 109     int         i, memfd;
 110
 111     if (argc < 2) {
 112         help(NULL);
 113     } else {
 114         if ((memfd = open(_PATH_MEM, O_RDONLY)) == -1)
 115             err(1, "can't open %s", _PATH_MEM);
 116
 117         for (i = 0; functions[i].cmd != NULL; i++)
 118             if (!strcmp(argv[1], functions[i].cmd))
 119                 break;
 120         functions[i].func(memfd, argc - 1, argv + 1);
 121         close(memfd);
 122     }
 123     return(0);
 124 }
 125
 126 static struct mem_range_desc *
 127 mrgetall(int memfd, int *nmr)
 128 {
 129     struct mem_range_desc       *mrd;
 130     struct mem_range_op         mro;
 131
 132     mro.mo_arg[0] = 0;
 133     if (ioctl(memfd, MEMRANGE_GET, &mro))
 134         err(1, "can't size range descriptor array");
 135
 136     *nmr = mro.mo_arg[0];
 137     mrd = malloc(*nmr * sizeof(struct mem_range_desc));
 138     if (mrd == NULL)
 139         errx(1, "can't allocate %zu bytes for %d range descriptors",
 140              *nmr * sizeof(struct mem_range_desc), *nmr);
 141
 142     mro.mo_arg[0] = *nmr;
 143     mro.mo_desc = mrd;
 144     if (ioctl(memfd, MEMRANGE_GET, &mro))
 145         err(1, "can't fetch range descriptor array");
 146
 147     return(mrd);
 148 }
 149
 150
 151 static void
 152 listfunc(int memfd, int argc, char *argv[])
 153 {
 154     struct mem_range_desc       *mrd;
 155     int                         nd, i, j;
 156     int                         ch;
 157     int                         showall = 0;
 158     char                        *owner;
 159
 160     owner = NULL;
 161     while ((ch = getopt(argc, argv, "ao:")) != -1)
 162         switch(ch) {
 163         case 'a':
 164             showall = 1;
 165             break;
 166         case 'o':
 167             owner = strdup(optarg);
 168             break;
 169         case '?':
 170         default:
 171             help("list");
 172         }
 173
 174     mrd = mrgetall(memfd, &nd);
 175
 176     for (i = 0; i < nd; i++) {
 177         if (!showall && !(mrd[i].mr_flags & MDF_ACTIVE))
 178             continue;
 179         if (owner && strcmp(mrd[i].mr_owner, owner))
 180             continue;
 181         printf("%jx/%jx %.8s ",
 182                (uintmax_t)mrd[i].mr_base, (uintmax_t)mrd[i].mr_len,
 183                mrd[i].mr_owner[0] ? mrd[i].mr_owner : "-");
 184         for (j = 0; attrnames[j].name != NULL; j++)
 185             if (mrd[i].mr_flags & attrnames[j].val)
 186                 printf("%s ", attrnames[j].name);
 187         printf("\n");
 188     }
 189     free(mrd);
 190     if (owner)
 191         free(owner);
 192 }
 193
 194 static void
 195 setfunc(int memfd, int argc, char *argv[])
 196 {
 197     struct mem_range_desc       mrd;
 198     struct mem_range_op         mro;
 199     int                         i;
 200     int                         ch;
 201     char                        *ep;
 202
 203     mrd.mr_base = 0;
 204     mrd.mr_len = 0;
 205     mrd.mr_flags = 0;
 206     strcpy(mrd.mr_owner, "user");
 207     while ((ch = getopt(argc, argv, "b:l:o:")) != -1)
 208         switch(ch) {
 209         case 'b':
 210             mrd.mr_base = strtouq(optarg, &ep, 0);
 211             if ((ep == optarg) || (*ep != 0))
 212                 help("set");
 213             break;
 214         case 'l':
 215             mrd.mr_len = strtouq(optarg, &ep, 0);
 216             if ((ep == optarg) || (*ep != 0))
 217                 help("set");
 218             break;
 219         case 'o':
 220             if ((*optarg == 0) || (strlen(optarg) > 7))
 221                 help("set");
 222             strcpy(mrd.mr_owner, optarg);
 223             break;
 224
 225         case '?':
 226         default:
 227             help("set");
 228         }
 229
 230     if (mrd.mr_len == 0)
 231         help("set");
 232
 233     argc -= optind;
 234     argv += optind;
 235
 236     while(argc--) {
 237         for (i = 0; attrnames[i].name != NULL; i++) {
 238             if (!strcmp(attrnames[i].name, argv[0])) {
 239                 if (!attrnames[i].kind & MDF_SETTABLE)
 240                     help("flags");
 241                 mrd.mr_flags |= attrnames[i].val;
 242                 break;
 243             }
 244         }
 245         if (attrnames[i].name == NULL)
 246             help("flags");
 247         argv++;
 248     }
 249
 250     mro.mo_desc = &mrd;
 251     mro.mo_arg[0] = 0;
 252     if (ioctl(memfd, MEMRANGE_SET, &mro))
 253         err(1, "can't set range");
 254 }
 255
 256 static void
 257 clearfunc(int memfd, int argc, char *argv[])
 258 {
 259     struct mem_range_desc       mrd, *mrdp;
 260     struct mem_range_op         mro;
 261     int                         i, nd;
 262     int                         ch;
 263     char                        *ep, *owner;
 264
 265     mrd.mr_base = 0;
 266     mrd.mr_len = 0;
 267     owner = NULL;
 268     while ((ch = getopt(argc, argv, "b:l:o:")) != -1)
 269         switch(ch) {
 270         case 'b':
 271             mrd.mr_base = strtouq(optarg, &ep, 0);
 272             if ((ep == optarg) || (*ep != 0))
 273                 help("clear");
 274             break;
 275         case 'l':
 276             mrd.mr_len = strtouq(optarg, &ep, 0);
 277             if ((ep == optarg) || (*ep != 0))
 278                 help("clear");
 279             break;
 280         case 'o':
 281             if ((*optarg == 0) || (strlen(optarg) > 7))
 282                 help("clear");
 283             owner = strdup(optarg);
 284             break;
 285
 286         case '?':
 287         default:
 288             help("clear");
 289         }
 290
 291     if (owner != NULL) {
 292         /* clear-by-owner */
 293         if ((mrd.mr_base != 0) || (mrd.mr_len != 0))
 294             help("clear");
 295
 296         mrdp = mrgetall(memfd, &nd);
 297         mro.mo_arg[0] = MEMRANGE_SET_REMOVE;
 298         for (i = 0; i < nd; i++) {
 299             if (!strcmp(owner, mrdp[i].mr_owner) &&
 300                 (mrdp[i].mr_flags & MDF_ACTIVE) &&
 301                 !(mrdp[i].mr_flags & MDF_FIXACTIVE)) {
 302
 303                 mro.mo_desc = mrdp + i;
 304                 if (ioctl(memfd, MEMRANGE_SET, &mro))
 305                     warn("couldn't clear range owned by '%s'", owner);
 306             }
 307         }
 308     } else if (mrd.mr_len != 0) {
 309         /* clear-by-base/len */
 310         mro.mo_arg[0] = MEMRANGE_SET_REMOVE;
 311         mro.mo_desc = &mrd;
 312         if (ioctl(memfd, MEMRANGE_SET, &mro))
 313             err(1, "couldn't clear range");
 314     } else {
 315         help("clear");
 316     }
 317 }
 318
 319 static void
 320 helpfunc(int memfd __unused, int argc __unused, char *argv[])
 321 {
 322     help(argv[1]);
 323 }
 324
 325 static void
 326 help(const char *what)
 327 {
 328     int         i;
 329
 330     if (what != NULL) {
 331         /* find a function that matches */
 332         for (i = 0; functions[i].cmd != NULL; i++)
 333             if (!strcmp(what, functions[i].cmd)) {
 334                 fprintf(stderr, "%s\n", functions[i].desc);
 335                 return;
 336             }
 337         fprintf(stderr, "Unknown command '%s'\n", what);
 338     }
 339
 340     /* print general help */
 341     fprintf(stderr, "Valid commands are :\n");
 342     for (i = 0; functions[i].cmd != NULL; i++)
 343         fprintf(stderr, "    %s\n", functions[i].cmd);
 344     fprintf(stderr, "Use help <command> for command-specific help\n");
 345 }