m5.c revision 12003:bbe320b2f604 
1/*
2 * Copyright (c) 2011, 2017 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder.  You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Copyright (c) 2003-2005 The Regents of The University of Michigan
15 * All rights reserved.
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions are
19 * met: redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer;
21 * redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution;
24 * neither the name of the copyright holders nor the names of its
25 * contributors may be used to endorse or promote products derived from
26 * this software without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 *
40 * Authors: Nathan Binkert
41 */
42
43#ifdef linux
44#define _GNU_SOURCE
45#include <sched.h>
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 *)(&regs[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,       "" },
351    { "initparam",      do_initparam,        "[key] // key must be shorter than 16 chars" },
352    { "sw99param",      do_sw99param,        "" },
353#ifdef linux
354    { "pin",            do_pin,              "<cpu> <program> [args ...]" }
355#endif
356};
357int numfuncs = sizeof(mainfuncs) / sizeof(mainfuncs[0]);
358
359void
360usage()
361{
362    int i;
363
364    for (i = 0; i < numfuncs; ++i) {
365        char *header = i ? "" : "usage:";
366        fprintf(stderr, "%-6s %s %s %s\n",
367                header, progname, mainfuncs[i].name, mainfuncs[i].usage);
368    }
369    fprintf(stderr, "\n");
370    fprintf(stderr, "All times in nanoseconds!\n");
371
372    exit(1);
373}
374
375static void
376map_m5_mem()
377{
378#ifdef M5OP_ADDR
379    int fd;
380
381    fd = open("/dev/mem", O_RDWR | O_SYNC);
382    if (fd == -1) {
383        perror("Can't open /dev/mem");
384        exit(1);
385    }
386
387    m5_mem = mmap(NULL, 0x10000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, M5OP_ADDR);
388    if (!m5_mem) {
389        perror("Can't mmap /dev/mem");
390        exit(1);
391    }
392#endif
393}
394
395int
396main(int argc, char *argv[])
397{
398    progname = argv[0];
399    if (argc < 2)
400        usage(1);
401
402    map_m5_mem();
403
404    command = argv[1];
405
406    argv += 2;
407    argc -= 2;
408
409    int i;
410    for (i = 0; i < numfuncs; ++i) {
411        if (strcmp(command, mainfuncs[i].name) != 0)
412            continue;
413
414        mainfuncs[i].func(argc, argv);
415        exit(0);
416    }
417
418    usage(1);
419}
420