Merge branch 'vendor/GDB'
[dragonfly.git] / 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 }