util/m5/m5.c

   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
  61 void *m5_mem = NULL;
  62
  63 char *progname;
  64 char *command = "unspecified";
  65 void usage();
  66
  67 void
  68 parse_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
  86 void
  87 parse_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
 107 int
 108 read_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
 141 void
 142 write_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
 168 void
 169 do_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
 179 void
 180 do_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
 190 void
 191 do_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
 198 void
 199 do_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
 206 void
 207 do_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
 214 void
 215 do_read_file(int argc, char *argv[])
 216 {
 217     if (argc > 0)
 218         usage();
 219
 220     read_file(STDOUT_FILENO);
 221 }
 222
 223 void
 224 do_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
 234 void
 235 do_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
 251 void
 252 do_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
 259 void
 260 do_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
 271 void
 272 do_loadsymbol(int argc, char *argv[])
 273 {
 274     if (argc > 0)
 275         usage();
 276
 277     m5_loadsymbol();
 278 }
 279
 280 void
 281 do_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
 292 void
 293 do_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
 308 void
 309 do_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
 332 struct MainFunc
 333 {
 334     char *name;
 335     void (*func)(int argc, char *argv[]);
 336     char *usage;
 337 };
 338
 339 struct 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 };
 357 int numfuncs = sizeof(mainfuncs) / sizeof(mainfuncs[0]);
 358
 359 void
 360 usage()
 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
 375 static void
 376 map_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
 395 int
 396 main(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 }