2003-11-01 20:11:29 +01:00
|
|
|
/*
|
2012-01-10 01:08:20 +01:00
|
|
|
* Copyright (c) 2011 ARM Limited
|
|
|
|
* All rights reserved
|
|
|
|
*
|
|
|
|
* The license below extends only to copyright in the software and shall
|
|
|
|
* not be construed as granting a license to any other intellectual
|
|
|
|
* property including but not limited to intellectual property relating
|
|
|
|
* to a hardware implementation of the functionality of the software
|
|
|
|
* licensed hereunder. You may use the software subject to the license
|
|
|
|
* terms below provided that you ensure that this notice is replicated
|
|
|
|
* unmodified and in its entirety in all distributions of the software,
|
|
|
|
* modified or unmodified, in source code or in binary form.
|
|
|
|
*
|
2005-06-05 11:16:00 +02:00
|
|
|
* Copyright (c) 2003-2005 The Regents of The University of Michigan
|
2003-11-01 20:11:29 +01:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are
|
|
|
|
* met: redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer;
|
|
|
|
* redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution;
|
|
|
|
* neither the name of the copyright holders nor the names of its
|
|
|
|
* contributors may be used to endorse or promote products derived from
|
|
|
|
* this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
2006-06-01 01:26:56 +02:00
|
|
|
*
|
|
|
|
* Authors: Nathan Binkert
|
2003-11-01 20:11:29 +01:00
|
|
|
*/
|
|
|
|
|
2008-12-03 13:57:54 +01:00
|
|
|
#ifdef linux
|
|
|
|
#define _GNU_SOURCE
|
|
|
|
#include <sched.h>
|
|
|
|
#endif
|
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
#include <err.h>
|
|
|
|
#include <fcntl.h>
|
2011-04-15 19:44:06 +02:00
|
|
|
#include <inttypes.h>
|
2003-11-01 19:20:44 +01:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2013-09-30 12:20:53 +02:00
|
|
|
#include <sys/mman.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/types.h>
|
2006-08-18 01:16:03 +02:00
|
|
|
#include <unistd.h>
|
2003-11-01 19:20:44 +01:00
|
|
|
|
|
|
|
#include "m5op.h"
|
|
|
|
|
2013-09-30 12:20:53 +02:00
|
|
|
void *m5_mem = NULL;
|
|
|
|
|
2003-11-01 19:20:44 +01:00
|
|
|
char *progname;
|
2008-12-03 13:57:53 +01:00
|
|
|
char *command = "unspecified";
|
|
|
|
void usage();
|
2003-11-01 19:20:44 +01:00
|
|
|
|
|
|
|
void
|
2008-12-03 13:57:53 +01:00
|
|
|
parse_int_args(int argc, char *argv[], uint64_t ints[], int len)
|
2003-11-01 19:20:44 +01:00
|
|
|
{
|
2008-12-03 13:57:53 +01:00
|
|
|
if (argc > len)
|
|
|
|
usage();
|
2003-11-01 19:20:44 +01:00
|
|
|
|
2012-09-07 21:20:53 +02:00
|
|
|
// On 32 bit platforms we need to use strtoull to do the conversion
|
|
|
|
#ifdef __LP64__
|
|
|
|
#define strto64 strtoul
|
|
|
|
#else
|
|
|
|
#define strto64 strtoull
|
|
|
|
#endif
|
2008-12-03 13:57:53 +01:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < len; ++i)
|
2012-09-07 21:20:53 +02:00
|
|
|
ints[i] = (i < argc) ? strto64(argv[i], NULL, 0) : 0;
|
|
|
|
|
|
|
|
#undef strto64
|
2008-12-03 13:57:53 +01:00
|
|
|
}
|
2003-11-02 07:08:59 +01:00
|
|
|
|
2016-01-07 23:33:47 +01:00
|
|
|
void
|
|
|
|
parse_str_args_to_regs(int argc, char *argv[], uint64_t regs[], int len)
|
|
|
|
{
|
|
|
|
if (argc > 1 || strlen(argv[0]) > len * sizeof(uint64_t))
|
|
|
|
usage();
|
|
|
|
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
regs[i] = 0;
|
|
|
|
|
|
|
|
if (argc == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
int n;
|
|
|
|
for (n = 0, i = 0; i < len && n < strlen(argv[0]); n++) {
|
|
|
|
*((char *)(®s[i]) + (n % 8)) = argv[0][n];
|
|
|
|
if ((n % 8) == 7)
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-11-01 19:20:44 +01:00
|
|
|
int
|
2008-12-03 13:57:53 +01:00
|
|
|
read_file(int dest_fid)
|
2003-11-01 19:20:44 +01:00
|
|
|
{
|
2008-12-03 13:57:53 +01:00
|
|
|
char buf[256*1024];
|
|
|
|
int offset = 0;
|
|
|
|
int len;
|
2003-11-01 19:20:44 +01:00
|
|
|
|
2010-08-13 02:16:04 +02:00
|
|
|
// Touch all buffer pages to ensure they are mapped in the
|
|
|
|
// page table. This is required in the case of X86_FS, where
|
|
|
|
// Linux does demand paging.
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
while ((len = m5_readfile(buf, sizeof(buf), offset)) > 0) {
|
|
|
|
write(dest_fid, buf, len);
|
|
|
|
offset += len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-31 16:46:04 +01:00
|
|
|
int
|
|
|
|
write_file(const char *filename)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "opening %s\n", filename);
|
|
|
|
int src_fid = open(filename, O_RDONLY);
|
|
|
|
|
|
|
|
if (src_fid < 0) {
|
|
|
|
fprintf(stderr, "error opening %s\n", filename);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
char buf[256*1024];
|
|
|
|
int offset = 0;
|
|
|
|
int len;
|
|
|
|
int bytes = 0;
|
|
|
|
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
|
|
|
|
while ((len = read(src_fid, buf, sizeof(buf))) > 0) {
|
|
|
|
bytes += m5_writefile(buf, len, offset, filename);
|
|
|
|
offset += len;
|
|
|
|
}
|
|
|
|
fprintf(stderr, "written %d bytes\n", bytes);
|
|
|
|
|
|
|
|
close(src_fid);
|
|
|
|
}
|
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
void
|
|
|
|
do_exit(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
if (argc > 1)
|
2003-11-01 19:20:44 +01:00
|
|
|
usage();
|
|
|
|
|
2012-09-07 21:20:53 +02:00
|
|
|
uint64_t ints[1];
|
2013-01-07 22:56:37 +01:00
|
|
|
parse_int_args(argc, argv, ints, 1);
|
2012-09-07 21:20:53 +02:00
|
|
|
m5_exit(ints[0]);
|
2008-12-03 13:57:53 +01:00
|
|
|
}
|
2003-11-02 07:08:59 +01:00
|
|
|
|
2013-01-08 14:54:12 +01:00
|
|
|
void
|
|
|
|
do_fail(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
if (argc < 1 || argc > 2)
|
|
|
|
usage();
|
|
|
|
|
2013-10-31 19:41:13 +01:00
|
|
|
uint64_t ints[2] = {0,0};
|
|
|
|
parse_int_args(argc, argv, ints, argc);
|
|
|
|
m5_fail(ints[1], ints[0]);
|
2013-01-08 14:54:12 +01:00
|
|
|
}
|
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
void
|
|
|
|
do_reset_stats(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
uint64_t ints[2];
|
|
|
|
parse_int_args(argc, argv, ints, 2);
|
|
|
|
m5_reset_stats(ints[0], ints[1]);
|
|
|
|
}
|
2003-11-02 07:08:59 +01:00
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
void
|
|
|
|
do_dump_stats(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
uint64_t ints[2];
|
|
|
|
parse_int_args(argc, argv, ints, 2);
|
|
|
|
m5_dump_stats(ints[0], ints[1]);
|
|
|
|
}
|
2003-11-02 07:08:59 +01:00
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
void
|
|
|
|
do_dump_reset_stats(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
uint64_t ints[2];
|
|
|
|
parse_int_args(argc, argv, ints, 2);
|
|
|
|
m5_dumpreset_stats(ints[0], ints[1]);
|
|
|
|
}
|
2003-11-01 19:20:44 +01:00
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
void
|
|
|
|
do_read_file(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
if (argc > 0)
|
|
|
|
usage();
|
2003-11-02 07:08:59 +01:00
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
read_file(STDOUT_FILENO);
|
|
|
|
}
|
2003-11-02 07:08:59 +01:00
|
|
|
|
2012-01-31 16:46:04 +01:00
|
|
|
void
|
|
|
|
do_write_file(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
if (argc != 1)
|
|
|
|
usage();
|
|
|
|
|
|
|
|
const char *filename = argv[0];
|
|
|
|
|
|
|
|
write_file(filename);
|
|
|
|
}
|
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
void
|
|
|
|
do_exec_file(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
if (argc > 0)
|
|
|
|
usage();
|
2003-11-02 07:08:59 +01:00
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
const char *destname = "/tmp/execfile";
|
2003-11-02 07:08:59 +01:00
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
int fid = open(destname, O_WRONLY, 0777);
|
|
|
|
int len = read_file(fid);
|
|
|
|
close(fid);
|
|
|
|
if (len > 0) {
|
|
|
|
execl(destname, "execfile", NULL);
|
|
|
|
err(1, "execl failed!");
|
2003-11-02 07:08:59 +01:00
|
|
|
}
|
2008-12-03 13:57:53 +01:00
|
|
|
}
|
2003-11-02 07:08:59 +01:00
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
void
|
|
|
|
do_checkpoint(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
uint64_t ints[2];
|
|
|
|
parse_int_args(argc, argv, ints, 2);
|
|
|
|
m5_checkpoint(ints[0], ints[1]);
|
|
|
|
}
|
2003-11-02 07:08:59 +01:00
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
void
|
|
|
|
do_load_symbol(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
if (argc != 2)
|
|
|
|
usage();
|
2006-08-23 22:57:07 +02:00
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
uint64_t addr = strtoul(argv[0], NULL, 0);
|
|
|
|
char *symbol = argv[1];
|
|
|
|
m5_loadsymbol(addr, symbol);
|
|
|
|
}
|
2006-08-23 22:57:07 +02:00
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
void
|
|
|
|
do_initparam(int argc, char *argv[])
|
|
|
|
{
|
2016-01-07 23:33:47 +01:00
|
|
|
if (argc > 1)
|
2008-12-03 13:57:53 +01:00
|
|
|
usage();
|
2006-08-23 22:57:07 +02:00
|
|
|
|
2016-01-07 23:33:47 +01:00
|
|
|
uint64_t key_str[2];
|
|
|
|
parse_str_args_to_regs(argc, argv, key_str, 2);
|
|
|
|
uint64_t val = m5_initparam(key_str[0], key_str[1]);
|
2012-01-10 01:08:20 +01:00
|
|
|
printf("%"PRIu64, val);
|
2008-12-03 13:57:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
do_sw99param(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
if (argc != 0)
|
|
|
|
usage();
|
|
|
|
|
2016-01-07 23:33:47 +01:00
|
|
|
uint64_t param = m5_initparam(0, 0);
|
2008-12-03 13:57:53 +01:00
|
|
|
|
|
|
|
// run-time, rampup-time, rampdown-time, warmup-time, connections
|
2012-09-07 21:20:53 +02:00
|
|
|
printf("%"PRId64" %"PRId64" %"PRId64" %"PRId64" %"PRId64,
|
|
|
|
(param >> 48) & 0xfff,
|
2008-12-03 13:57:53 +01:00
|
|
|
(param >> 36) & 0xfff, (param >> 24) & 0xfff,
|
|
|
|
(param >> 12) & 0xfff, (param >> 0) & 0xfff);
|
|
|
|
}
|
|
|
|
|
2008-12-03 13:57:54 +01:00
|
|
|
#ifdef linux
|
|
|
|
void
|
|
|
|
do_pin(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
if (argc < 2)
|
|
|
|
usage();
|
|
|
|
|
2016-02-07 02:21:18 +01:00
|
|
|
cpu_set_t mask;
|
2008-12-03 13:57:54 +01:00
|
|
|
CPU_ZERO(&mask);
|
|
|
|
|
|
|
|
const char *sep = ",";
|
|
|
|
char *target = strtok(argv[0], sep);
|
|
|
|
while (target) {
|
|
|
|
CPU_SET(atoi(target), &mask);
|
|
|
|
target = strtok(NULL, sep);
|
2016-02-07 02:21:18 +01:00
|
|
|
}
|
2008-12-03 13:57:54 +01:00
|
|
|
|
|
|
|
if (sched_setaffinity(0, sizeof(cpu_set_t), &mask) < 0)
|
|
|
|
err(1, "setaffinity");
|
|
|
|
|
|
|
|
execvp(argv[1], &argv[1]);
|
|
|
|
err(1, "execvp failed!");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
struct MainFunc
|
|
|
|
{
|
|
|
|
char *name;
|
|
|
|
void (*func)(int argc, char *argv[]);
|
|
|
|
char *usage;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct MainFunc mainfuncs[] = {
|
|
|
|
{ "exit", do_exit, "[delay]" },
|
2013-01-08 14:54:12 +01:00
|
|
|
{ "fail", do_fail, "<code> [delay]" },
|
2008-12-03 13:57:53 +01:00
|
|
|
{ "resetstats", do_reset_stats, "[delay [period]]" },
|
|
|
|
{ "dumpstats", do_dump_stats, "[delay [period]]" },
|
|
|
|
{ "dumpresetstats", do_dump_reset_stats, "[delay [period]]" },
|
2012-01-31 16:46:04 +01:00
|
|
|
{ "readfile", do_read_file, "" },
|
|
|
|
{ "writefile", do_write_file, "<filename>" },
|
|
|
|
{ "execfile", do_exec_file, "" },
|
2008-12-03 13:57:53 +01:00
|
|
|
{ "checkpoint", do_checkpoint, "[delay [period]]" },
|
|
|
|
{ "loadsymbol", do_load_symbol, "<address> <symbol>" },
|
2016-01-07 23:33:47 +01:00
|
|
|
{ "initparam", do_initparam, "[key] // key must be shorter than 16 chars" },
|
2008-12-03 13:57:53 +01:00
|
|
|
{ "sw99param", do_sw99param, "" },
|
2008-12-03 13:57:54 +01:00
|
|
|
#ifdef linux
|
|
|
|
{ "pin", do_pin, "<cpu> <program> [args ...]" }
|
|
|
|
#endif
|
2008-12-03 13:57:53 +01:00
|
|
|
};
|
|
|
|
int numfuncs = sizeof(mainfuncs) / sizeof(mainfuncs[0]);
|
|
|
|
|
|
|
|
void
|
|
|
|
usage()
|
|
|
|
{
|
|
|
|
int i;
|
2006-08-23 22:57:07 +02:00
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
for (i = 0; i < numfuncs; ++i) {
|
|
|
|
char *header = i ? "" : "usage:";
|
|
|
|
fprintf(stderr, "%-6s %s %s %s\n",
|
|
|
|
header, progname, mainfuncs[i].name, mainfuncs[i].usage);
|
2003-11-01 19:20:44 +01:00
|
|
|
}
|
2008-12-03 13:57:53 +01:00
|
|
|
fprintf(stderr, "\n");
|
|
|
|
fprintf(stderr, "All times in nanoseconds!\n");
|
2003-11-01 19:20:44 +01:00
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2013-09-30 12:20:53 +02:00
|
|
|
static void
|
|
|
|
map_m5_mem()
|
|
|
|
{
|
|
|
|
#ifdef M5OP_ADDR
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
fd = open("/dev/mem", O_RDWR | O_SYNC);
|
|
|
|
if (fd == -1) {
|
|
|
|
perror("Can't open /dev/mem");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
m5_mem = mmap(NULL, 0x10000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, M5OP_ADDR);
|
|
|
|
if (!m5_mem) {
|
|
|
|
perror("Can't mmap /dev/mem");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
int
|
|
|
|
main(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
progname = argv[0];
|
|
|
|
if (argc < 2)
|
|
|
|
usage(1);
|
|
|
|
|
2013-09-30 12:20:53 +02:00
|
|
|
map_m5_mem();
|
|
|
|
|
2008-12-03 13:57:53 +01:00
|
|
|
command = argv[1];
|
|
|
|
|
|
|
|
argv += 2;
|
|
|
|
argc -= 2;
|
|
|
|
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < numfuncs; ++i) {
|
|
|
|
if (strcmp(command, mainfuncs[i].name) != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
mainfuncs[i].func(argc, argv);
|
|
|
|
exit(0);
|
2007-02-22 03:06:17 +01:00
|
|
|
}
|
2008-12-03 13:57:53 +01:00
|
|
|
|
|
|
|
usage(1);
|
2003-11-01 19:20:44 +01:00
|
|
|
}
|