monitor/hmp-cmds-target.c

   1 /*
   2  * Miscellaneous target-dependent HMP commands
   3  *
   4  * Copyright (c) 2003-2004 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include "disas/disas.h"
  27 #include "exec/address-spaces.h"
  28 #include "monitor/hmp-target.h"
  29 #include "monitor/monitor-internal.h"
  30 #include "qapi/error.h"
  31 #include "qapi/qmp/qdict.h"
  32 #include "sysemu/hw_accel.h"
  33
  34 /* Set the current CPU defined by the user. Callers must hold BQL. */
  35 int monitor_set_cpu(Monitor *mon, int cpu_index)
  36 {
  37     CPUState *cpu;
  38
  39     cpu = qemu_get_cpu(cpu_index);
  40     if (cpu == NULL) {
  41         return -1;
  42     }
  43     g_free(mon->mon_cpu_path);
  44     mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
  45     return 0;
  46 }
  47
  48 /* Callers must hold BQL. */
  49 static CPUState *mon_get_cpu_sync(Monitor *mon, bool synchronize)
  50 {
  51     CPUState *cpu = NULL;
  52
  53     if (mon->mon_cpu_path) {
  54         cpu = (CPUState *) object_resolve_path_type(mon->mon_cpu_path,
  55                                                     TYPE_CPU, NULL);
  56         if (!cpu) {
  57             g_free(mon->mon_cpu_path);
  58             mon->mon_cpu_path = NULL;
  59         }
  60     }
  61     if (!mon->mon_cpu_path) {
  62         if (!first_cpu) {
  63             return NULL;
  64         }
  65         monitor_set_cpu(mon, first_cpu->cpu_index);
  66         cpu = first_cpu;
  67     }
  68     assert(cpu != NULL);
  69     if (synchronize) {
  70         cpu_synchronize_state(cpu);
  71     }
  72     return cpu;
  73 }
  74
  75 CPUState *mon_get_cpu(Monitor *mon)
  76 {
  77     return mon_get_cpu_sync(mon, true);
  78 }
  79
  80 CPUArchState *mon_get_cpu_env(Monitor *mon)
  81 {
  82     CPUState *cs = mon_get_cpu(mon);
  83
  84     return cs ? cs->env_ptr : NULL;
  85 }
  86
  87 int monitor_get_cpu_index(Monitor *mon)
  88 {
  89     CPUState *cs = mon_get_cpu_sync(mon, false);
  90
  91     return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
  92 }
  93
  94 void hmp_info_registers(Monitor *mon, const QDict *qdict)
  95 {
  96     bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
  97     int vcpu = qdict_get_try_int(qdict, "vcpu", -1);
  98     CPUState *cs;
  99
 100     if (all_cpus) {
 101         CPU_FOREACH(cs) {
 102             monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
 103             cpu_dump_state(cs, NULL, CPU_DUMP_FPU);
 104         }
 105     } else {
 106         cs = vcpu >= 0 ? qemu_get_cpu(vcpu) : mon_get_cpu(mon);
 107
 108         if (!cs) {
 109             if (vcpu >= 0) {
 110                 monitor_printf(mon, "CPU#%d not available\n", vcpu);
 111             } else {
 112                 monitor_printf(mon, "No CPU available\n");
 113             }
 114             return;
 115         }
 116
 117         monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
 118         cpu_dump_state(cs, NULL, CPU_DUMP_FPU);
 119     }
 120 }
 121
 122 static void memory_dump(Monitor *mon, int count, int format, int wsize,
 123                         hwaddr addr, int is_physical)
 124 {
 125     int l, line_size, i, max_digits, len;
 126     uint8_t buf[16];
 127     uint64_t v;
 128     CPUState *cs = mon_get_cpu(mon);
 129
 130     if (!cs && (format == 'i' || !is_physical)) {
 131         monitor_printf(mon, "Can not dump without CPU\n");
 132         return;
 133     }
 134
 135     if (format == 'i') {
 136         monitor_disas(mon, cs, addr, count, is_physical);
 137         return;
 138     }
 139
 140     len = wsize * count;
 141     if (wsize == 1) {
 142         line_size = 8;
 143     } else {
 144         line_size = 16;
 145     }
 146     max_digits = 0;
 147
 148     switch(format) {
 149     case 'o':
 150         max_digits = DIV_ROUND_UP(wsize * 8, 3);
 151         break;
 152     default:
 153     case 'x':
 154         max_digits = (wsize * 8) / 4;
 155         break;
 156     case 'u':
 157     case 'd':
 158         max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
 159         break;
 160     case 'c':
 161         wsize = 1;
 162         break;
 163     }
 164
 165     while (len > 0) {
 166         if (is_physical) {
 167             monitor_printf(mon, HWADDR_FMT_plx ":", addr);
 168         } else {
 169             monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
 170         }
 171         l = len;
 172         if (l > line_size)
 173             l = line_size;
 174         if (is_physical) {
 175             AddressSpace *as = cs ? cs->as : &address_space_memory;
 176             MemTxResult r = address_space_read(as, addr,
 177                                                MEMTXATTRS_UNSPECIFIED, buf, l);
 178             if (r != MEMTX_OK) {
 179                 monitor_printf(mon, " Cannot access memory\n");
 180                 break;
 181             }
 182         } else {
 183             if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
 184                 monitor_printf(mon, " Cannot access memory\n");
 185                 break;
 186             }
 187         }
 188         i = 0;
 189         while (i < l) {
 190             switch(wsize) {
 191             default:
 192             case 1:
 193                 v = ldub_p(buf + i);
 194                 break;
 195             case 2:
 196                 v = lduw_p(buf + i);
 197                 break;
 198             case 4:
 199                 v = (uint32_t)ldl_p(buf + i);
 200                 break;
 201             case 8:
 202                 v = ldq_p(buf + i);
 203                 break;
 204             }
 205             monitor_printf(mon, " ");
 206             switch(format) {
 207             case 'o':
 208                 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
 209                 break;
 210             case 'x':
 211                 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
 212                 break;
 213             case 'u':
 214                 monitor_printf(mon, "%*" PRIu64, max_digits, v);
 215                 break;
 216             case 'd':
 217                 monitor_printf(mon, "%*" PRId64, max_digits, v);
 218                 break;
 219             case 'c':
 220                 monitor_printc(mon, v);
 221                 break;
 222             }
 223             i += wsize;
 224         }
 225         monitor_printf(mon, "\n");
 226         addr += l;
 227         len -= l;
 228     }
 229 }
 230
 231 void hmp_memory_dump(Monitor *mon, const QDict *qdict)
 232 {
 233     int count = qdict_get_int(qdict, "count");
 234     int format = qdict_get_int(qdict, "format");
 235     int size = qdict_get_int(qdict, "size");
 236     target_long addr = qdict_get_int(qdict, "addr");
 237
 238     memory_dump(mon, count, format, size, addr, 0);
 239 }
 240
 241 void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
 242 {
 243     int count = qdict_get_int(qdict, "count");
 244     int format = qdict_get_int(qdict, "format");
 245     int size = qdict_get_int(qdict, "size");
 246     hwaddr addr = qdict_get_int(qdict, "addr");
 247
 248     memory_dump(mon, count, format, size, addr, 1);
 249 }
 250
 251 void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, uint64_t size, Error **errp)
 252 {
 253     Int128 gpa_region_size;
 254     MemoryRegionSection mrs = memory_region_find(get_system_memory(),
 255                                                  addr, size);
 256
 257     if (!mrs.mr) {
 258         error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
 259         return NULL;
 260     }
 261
 262     if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
 263         error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
 264         memory_region_unref(mrs.mr);
 265         return NULL;
 266     }
 267
 268     gpa_region_size = int128_make64(size);
 269     if (int128_lt(mrs.size, gpa_region_size)) {
 270         error_setg(errp, "Size of memory region at 0x%" HWADDR_PRIx
 271                    " exceeded.", addr);
 272         memory_region_unref(mrs.mr);
 273         return NULL;
 274     }
 275
 276     *p_mr = mrs.mr;
 277     return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
 278 }
 279
 280 void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
 281 {
 282     hwaddr addr = qdict_get_int(qdict, "addr");
 283     Error *local_err = NULL;
 284     MemoryRegion *mr = NULL;
 285     void *ptr;
 286
 287     ptr = gpa2hva(&mr, addr, 1, &local_err);
 288     if (local_err) {
 289         error_report_err(local_err);
 290         return;
 291     }
 292
 293     monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
 294                    " (%s) is %p\n",
 295                    addr, mr->name, ptr);
 296
 297     memory_region_unref(mr);
 298 }
 299
 300 void hmp_gva2gpa(Monitor *mon, const QDict *qdict)
 301 {
 302     target_ulong addr = qdict_get_int(qdict, "addr");
 303     MemTxAttrs attrs;
 304     CPUState *cs = mon_get_cpu(mon);
 305     hwaddr gpa;
 306
 307     if (!cs) {
 308         monitor_printf(mon, "No cpu\n");
 309         return;
 310     }
 311
 312     gpa  = cpu_get_phys_page_attrs_debug(cs, addr & TARGET_PAGE_MASK, &attrs);
 313     if (gpa == -1) {
 314         monitor_printf(mon, "Unmapped\n");
 315     } else {
 316         monitor_printf(mon, "gpa: %#" HWADDR_PRIx "\n",
 317                        gpa + (addr & ~TARGET_PAGE_MASK));
 318     }
 319 }
 320
 321 #ifdef CONFIG_LINUX
 322 static uint64_t vtop(void *ptr, Error **errp)
 323 {
 324     uint64_t pinfo;
 325     uint64_t ret = -1;
 326     uintptr_t addr = (uintptr_t) ptr;
 327     uintptr_t pagesize = qemu_real_host_page_size();
 328     off_t offset = addr / pagesize * sizeof(pinfo);
 329     int fd;
 330
 331     fd = open("/proc/self/pagemap", O_RDONLY);
 332     if (fd == -1) {
 333         error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
 334         return -1;
 335     }
 336
 337     /* Force copy-on-write if necessary.  */
 338     qatomic_add((uint8_t *)ptr, 0);
 339
 340     if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
 341         error_setg_errno(errp, errno, "Cannot read pagemap");
 342         goto out;
 343     }
 344     if ((pinfo & (1ull << 63)) == 0) {
 345         error_setg(errp, "Page not present");
 346         goto out;
 347     }
 348     ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
 349
 350 out:
 351     close(fd);
 352     return ret;
 353 }
 354
 355 void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
 356 {
 357     hwaddr addr = qdict_get_int(qdict, "addr");
 358     Error *local_err = NULL;
 359     MemoryRegion *mr = NULL;
 360     void *ptr;
 361     uint64_t physaddr;
 362
 363     ptr = gpa2hva(&mr, addr, 1, &local_err);
 364     if (local_err) {
 365         error_report_err(local_err);
 366         return;
 367     }
 368
 369     physaddr = vtop(ptr, &local_err);
 370     if (local_err) {
 371         error_report_err(local_err);
 372     } else {
 373         monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
 374                        " (%s) is 0x%" PRIx64 "\n",
 375                        addr, mr->name, (uint64_t) physaddr);
 376     }
 377
 378     memory_region_unref(mr);
 379 }
 380 #endif