46#endif
47
48#include <err.h>
49#include <fcntl.h>
50#include <inttypes.h>
51#include <stdio.h>
52#include <stdlib.h>
53#include <string.h>
54#include <sys/mman.h>
55#include <sys/stat.h>
56#include <sys/types.h>
57#include <unistd.h>
58
59#include "m5op.h"
60
61void *m5_mem = NULL;
62
63char *progname;
64char *command = "unspecified";
65void usage();
66
67void
68parse_int_args(int argc, char *argv[], uint64_t ints[], int len)
69{
70 if (argc > len)
71 usage();
72
73// On 32 bit platforms we need to use strtoull to do the conversion
74#ifdef __LP64__
75#define strto64 strtoul
76#else
77#define strto64 strtoull
78#endif
79 int i;
80 for (i = 0; i < len; ++i)
81 ints[i] = (i < argc) ? strto64(argv[i], NULL, 0) : 0;
82
83#undef strto64
84}
85
86void
87parse_str_args_to_regs(int argc, char *argv[], uint64_t regs[], int len)
88{
89 if (argc > 1 || (argc > 0 && strlen(argv[0]) > len * sizeof(uint64_t)))
90 usage();
91
92 int i;
93 for (i = 0; i < len; i++)
94 regs[i] = 0;
95
96 if (argc == 0)
97 return;
98
99 int n;
100 for (n = 0, i = 0; i < len && n < strlen(argv[0]); n++) {
101 *((char *)(®s[i]) + (n % 8)) = argv[0][n];
102 if ((n % 8) == 7)
103 i++;
104 }
105}
106
107int
108read_file(int dest_fid)
109{
110 uint8_t buf[256*1024];
111 int offset = 0;
112 int len, ret;
113
114 // Touch all buffer pages to ensure they are mapped in the
115 // page table. This is required in the case of X86_FS, where
116 // Linux does demand paging.
117 memset(buf, 0, sizeof(buf));
118
119 while ((len = m5_readfile(buf, sizeof(buf), offset)) > 0) {
120 uint8_t *base = buf;
121 offset += len;
122 do {
123 ret = write(dest_fid, base, len);
124 if (ret < 0) {
125 perror("Failed to write file");
126 exit(2);
127 } else if (ret == 0) {
128 fprintf(stderr, "Failed to write file: "
129 "Unhandled short write\n");
130 exit(2);
131 }
132
133 base += ret;
134 len -= ret;
135 } while (len);
136 }
137
138 return offset;
139}
140
141void
142write_file(const char *filename)
143{
144 fprintf(stderr, "opening %s\n", filename);
145 int src_fid = open(filename, O_RDONLY);
146
147 if (src_fid < 0) {
148 fprintf(stderr, "error opening %s\n", filename);
149 return;
150 }
151
152 char buf[256*1024];
153 int offset = 0;
154 int len;
155 int bytes = 0;
156
157 memset(buf, 0, sizeof(buf));
158
159 while ((len = read(src_fid, buf, sizeof(buf))) > 0) {
160 bytes += m5_writefile(buf, len, offset, filename);
161 offset += len;
162 }
163 fprintf(stderr, "written %d bytes\n", bytes);
164
165 close(src_fid);
166}
167
168void
169do_exit(int argc, char *argv[])
170{
171 if (argc > 1)
172 usage();
173
174 uint64_t ints[1];
175 parse_int_args(argc, argv, ints, 1);
176 m5_exit(ints[0]);
177}
178
179void
180do_fail(int argc, char *argv[])
181{
182 if (argc < 1 || argc > 2)
183 usage();
184
185 uint64_t ints[2] = {0,0};
186 parse_int_args(argc, argv, ints, argc);
187 m5_fail(ints[1], ints[0]);
188}
189
190void
191do_reset_stats(int argc, char *argv[])
192{
193 uint64_t ints[2];
194 parse_int_args(argc, argv, ints, 2);
195 m5_reset_stats(ints[0], ints[1]);
196}
197
198void
199do_dump_stats(int argc, char *argv[])
200{
201 uint64_t ints[2];
202 parse_int_args(argc, argv, ints, 2);
203 m5_dump_stats(ints[0], ints[1]);
204}
205
206void
207do_dump_reset_stats(int argc, char *argv[])
208{
209 uint64_t ints[2];
210 parse_int_args(argc, argv, ints, 2);
211 m5_dumpreset_stats(ints[0], ints[1]);
212}
213
214void
215do_read_file(int argc, char *argv[])
216{
217 if (argc > 0)
218 usage();
219
220 read_file(STDOUT_FILENO);
221}
222
223void
224do_write_file(int argc, char *argv[])
225{
226 if (argc != 1)
227 usage();
228
229 const char *filename = argv[0];
230
231 write_file(filename);
232}
233
234void
235do_exec_file(int argc, char *argv[])
236{
237 if (argc > 0)
238 usage();
239
240 const char *destname = "/tmp/execfile";
241
242 int fid = open(destname, O_WRONLY, 0777);
243 int len = read_file(fid);
244 close(fid);
245 if (len > 0) {
246 execl(destname, "execfile", NULL);
247 err(1, "execl failed!");
248 }
249}
250
251void
252do_checkpoint(int argc, char *argv[])
253{
254 uint64_t ints[2];
255 parse_int_args(argc, argv, ints, 2);
256 m5_checkpoint(ints[0], ints[1]);
257}
258
259void
260do_addsymbol(int argc, char *argv[])
261{
262 if (argc != 2)
263 usage();
264
265 uint64_t addr = strtoul(argv[0], NULL, 0);
266 char *symbol = argv[1];
267 m5_addsymbol(addr, symbol);
268}
269
270
271void
272do_loadsymbol(int argc, char *argv[])
273{
274 if (argc > 0)
275 usage();
276
277 m5_loadsymbol();
278}
279
280void
281do_initparam(int argc, char *argv[])
282{
283 if (argc > 1)
284 usage();
285
286 uint64_t key_str[2];
287 parse_str_args_to_regs(argc, argv, key_str, 2);
288 uint64_t val = m5_initparam(key_str[0], key_str[1]);
289 printf("%"PRIu64, val);
290}
291
292void
293do_sw99param(int argc, char *argv[])
294{
295 if (argc != 0)
296 usage();
297
298 uint64_t param = m5_initparam(0, 0);
299
300 // run-time, rampup-time, rampdown-time, warmup-time, connections
301 printf("%"PRId64" %"PRId64" %"PRId64" %"PRId64" %"PRId64,
302 (param >> 48) & 0xfff,
303 (param >> 36) & 0xfff, (param >> 24) & 0xfff,
304 (param >> 12) & 0xfff, (param >> 0) & 0xfff);
305}
306
307#ifdef linux
308void
309do_pin(int argc, char *argv[])
310{
311 if (argc < 2)
312 usage();
313
314 cpu_set_t mask;
315 CPU_ZERO(&mask);
316
317 const char *sep = ",";
318 char *target = strtok(argv[0], sep);
319 while (target) {
320 CPU_SET(atoi(target), &mask);
321 target = strtok(NULL, sep);
322 }
323
324 if (sched_setaffinity(0, sizeof(cpu_set_t), &mask) < 0)
325 err(1, "setaffinity");
326
327 execvp(argv[1], &argv[1]);
328 err(1, "execvp failed!");
329}
330#endif
331
332struct MainFunc
333{
334 char *name;
335 void (*func)(int argc, char *argv[]);
336 char *usage;
337};
338
339struct MainFunc mainfuncs[] = {
340 { "exit", do_exit, "[delay]" },
341 { "fail", do_fail, "<code> [delay]" },
342 { "resetstats", do_reset_stats, "[delay [period]]" },
343 { "dumpstats", do_dump_stats, "[delay [period]]" },
344 { "dumpresetstats", do_dump_reset_stats, "[delay [period]]" },
345 { "readfile", do_read_file, "" },
346 { "writefile", do_write_file, "<filename>" },
347 { "execfile", do_exec_file, "" },
348 { "checkpoint", do_checkpoint, "[delay [period]]" },
349 { "addsymbol", do_addsymbol, "<address> <symbol>" },
350 { "loadsymbol", do_loadsymbol, "" },
| 47#endif
48
49#include <err.h>
50#include <fcntl.h>
51#include <inttypes.h>
52#include <stdio.h>
53#include <stdlib.h>
54#include <string.h>
55#include <sys/mman.h>
56#include <sys/stat.h>
57#include <sys/types.h>
58#include <unistd.h>
59
60#include "m5op.h"
61
62void *m5_mem = NULL;
63
64char *progname;
65char *command = "unspecified";
66void usage();
67
68void
69parse_int_args(int argc, char *argv[], uint64_t ints[], int len)
70{
71 if (argc > len)
72 usage();
73
74// On 32 bit platforms we need to use strtoull to do the conversion
75#ifdef __LP64__
76#define strto64 strtoul
77#else
78#define strto64 strtoull
79#endif
80 int i;
81 for (i = 0; i < len; ++i)
82 ints[i] = (i < argc) ? strto64(argv[i], NULL, 0) : 0;
83
84#undef strto64
85}
86
87void
88parse_str_args_to_regs(int argc, char *argv[], uint64_t regs[], int len)
89{
90 if (argc > 1 || (argc > 0 && strlen(argv[0]) > len * sizeof(uint64_t)))
91 usage();
92
93 int i;
94 for (i = 0; i < len; i++)
95 regs[i] = 0;
96
97 if (argc == 0)
98 return;
99
100 int n;
101 for (n = 0, i = 0; i < len && n < strlen(argv[0]); n++) {
102 *((char *)(®s[i]) + (n % 8)) = argv[0][n];
103 if ((n % 8) == 7)
104 i++;
105 }
106}
107
108int
109read_file(int dest_fid)
110{
111 uint8_t buf[256*1024];
112 int offset = 0;
113 int len, ret;
114
115 // Touch all buffer pages to ensure they are mapped in the
116 // page table. This is required in the case of X86_FS, where
117 // Linux does demand paging.
118 memset(buf, 0, sizeof(buf));
119
120 while ((len = m5_readfile(buf, sizeof(buf), offset)) > 0) {
121 uint8_t *base = buf;
122 offset += len;
123 do {
124 ret = write(dest_fid, base, len);
125 if (ret < 0) {
126 perror("Failed to write file");
127 exit(2);
128 } else if (ret == 0) {
129 fprintf(stderr, "Failed to write file: "
130 "Unhandled short write\n");
131 exit(2);
132 }
133
134 base += ret;
135 len -= ret;
136 } while (len);
137 }
138
139 return offset;
140}
141
142void
143write_file(const char *filename)
144{
145 fprintf(stderr, "opening %s\n", filename);
146 int src_fid = open(filename, O_RDONLY);
147
148 if (src_fid < 0) {
149 fprintf(stderr, "error opening %s\n", filename);
150 return;
151 }
152
153 char buf[256*1024];
154 int offset = 0;
155 int len;
156 int bytes = 0;
157
158 memset(buf, 0, sizeof(buf));
159
160 while ((len = read(src_fid, buf, sizeof(buf))) > 0) {
161 bytes += m5_writefile(buf, len, offset, filename);
162 offset += len;
163 }
164 fprintf(stderr, "written %d bytes\n", bytes);
165
166 close(src_fid);
167}
168
169void
170do_exit(int argc, char *argv[])
171{
172 if (argc > 1)
173 usage();
174
175 uint64_t ints[1];
176 parse_int_args(argc, argv, ints, 1);
177 m5_exit(ints[0]);
178}
179
180void
181do_fail(int argc, char *argv[])
182{
183 if (argc < 1 || argc > 2)
184 usage();
185
186 uint64_t ints[2] = {0,0};
187 parse_int_args(argc, argv, ints, argc);
188 m5_fail(ints[1], ints[0]);
189}
190
191void
192do_reset_stats(int argc, char *argv[])
193{
194 uint64_t ints[2];
195 parse_int_args(argc, argv, ints, 2);
196 m5_reset_stats(ints[0], ints[1]);
197}
198
199void
200do_dump_stats(int argc, char *argv[])
201{
202 uint64_t ints[2];
203 parse_int_args(argc, argv, ints, 2);
204 m5_dump_stats(ints[0], ints[1]);
205}
206
207void
208do_dump_reset_stats(int argc, char *argv[])
209{
210 uint64_t ints[2];
211 parse_int_args(argc, argv, ints, 2);
212 m5_dumpreset_stats(ints[0], ints[1]);
213}
214
215void
216do_read_file(int argc, char *argv[])
217{
218 if (argc > 0)
219 usage();
220
221 read_file(STDOUT_FILENO);
222}
223
224void
225do_write_file(int argc, char *argv[])
226{
227 if (argc != 1)
228 usage();
229
230 const char *filename = argv[0];
231
232 write_file(filename);
233}
234
235void
236do_exec_file(int argc, char *argv[])
237{
238 if (argc > 0)
239 usage();
240
241 const char *destname = "/tmp/execfile";
242
243 int fid = open(destname, O_WRONLY, 0777);
244 int len = read_file(fid);
245 close(fid);
246 if (len > 0) {
247 execl(destname, "execfile", NULL);
248 err(1, "execl failed!");
249 }
250}
251
252void
253do_checkpoint(int argc, char *argv[])
254{
255 uint64_t ints[2];
256 parse_int_args(argc, argv, ints, 2);
257 m5_checkpoint(ints[0], ints[1]);
258}
259
260void
261do_addsymbol(int argc, char *argv[])
262{
263 if (argc != 2)
264 usage();
265
266 uint64_t addr = strtoul(argv[0], NULL, 0);
267 char *symbol = argv[1];
268 m5_addsymbol(addr, symbol);
269}
270
271
272void
273do_loadsymbol(int argc, char *argv[])
274{
275 if (argc > 0)
276 usage();
277
278 m5_loadsymbol();
279}
280
281void
282do_initparam(int argc, char *argv[])
283{
284 if (argc > 1)
285 usage();
286
287 uint64_t key_str[2];
288 parse_str_args_to_regs(argc, argv, key_str, 2);
289 uint64_t val = m5_initparam(key_str[0], key_str[1]);
290 printf("%"PRIu64, val);
291}
292
293void
294do_sw99param(int argc, char *argv[])
295{
296 if (argc != 0)
297 usage();
298
299 uint64_t param = m5_initparam(0, 0);
300
301 // run-time, rampup-time, rampdown-time, warmup-time, connections
302 printf("%"PRId64" %"PRId64" %"PRId64" %"PRId64" %"PRId64,
303 (param >> 48) & 0xfff,
304 (param >> 36) & 0xfff, (param >> 24) & 0xfff,
305 (param >> 12) & 0xfff, (param >> 0) & 0xfff);
306}
307
308#ifdef linux
309void
310do_pin(int argc, char *argv[])
311{
312 if (argc < 2)
313 usage();
314
315 cpu_set_t mask;
316 CPU_ZERO(&mask);
317
318 const char *sep = ",";
319 char *target = strtok(argv[0], sep);
320 while (target) {
321 CPU_SET(atoi(target), &mask);
322 target = strtok(NULL, sep);
323 }
324
325 if (sched_setaffinity(0, sizeof(cpu_set_t), &mask) < 0)
326 err(1, "setaffinity");
327
328 execvp(argv[1], &argv[1]);
329 err(1, "execvp failed!");
330}
331#endif
332
333struct MainFunc
334{
335 char *name;
336 void (*func)(int argc, char *argv[]);
337 char *usage;
338};
339
340struct MainFunc mainfuncs[] = {
341 { "exit", do_exit, "[delay]" },
342 { "fail", do_fail, "<code> [delay]" },
343 { "resetstats", do_reset_stats, "[delay [period]]" },
344 { "dumpstats", do_dump_stats, "[delay [period]]" },
345 { "dumpresetstats", do_dump_reset_stats, "[delay [period]]" },
346 { "readfile", do_read_file, "" },
347 { "writefile", do_write_file, "<filename>" },
348 { "execfile", do_exec_file, "" },
349 { "checkpoint", do_checkpoint, "[delay [period]]" },
350 { "addsymbol", do_addsymbol, "<address> <symbol>" },
351 { "loadsymbol", do_loadsymbol, "" },
|