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 381