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