[mirror_qemu.git] / monitor / hmp-cmds-target.c

/*
 * Miscellaneous target-dependent HMP commands
 *
 * Copyright (c) 2003-2004 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "qemu/osdep.h"
#include "disas/disas.h"
#include "exec/address-spaces.h"
#include "monitor/hmp-target.h"
#include "monitor/monitor-internal.h"
#include "qapi/error.h"
#include "qapi/qmp/qdict.h"
#include "sysemu/hw_accel.h"

/* Set the current CPU defined by the user. Callers must hold BQL. */
int monitor_set_cpu(Monitor *mon, int cpu_index)
{
    CPUState *cpu;

    cpu = qemu_get_cpu(cpu_index);
    if (cpu == NULL) {
        return -1;
    }
    g_free(mon->mon_cpu_path);
    mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
    return 0;
}

/* Callers must hold BQL. */
static CPUState *mon_get_cpu_sync(Monitor *mon, bool synchronize)
{
    CPUState *cpu = NULL;

    if (mon->mon_cpu_path) {
        cpu = (CPUState *) object_resolve_path_type(mon->mon_cpu_path,
                                                    TYPE_CPU, NULL);
        if (!cpu) {
            g_free(mon->mon_cpu_path);
            mon->mon_cpu_path = NULL;
        }
    }
    if (!mon->mon_cpu_path) {
        if (!first_cpu) {
            return NULL;
        }
        monitor_set_cpu(mon, first_cpu->cpu_index);
        cpu = first_cpu;
    }
    assert(cpu != NULL);
    if (synchronize) {
        cpu_synchronize_state(cpu);
    }
    return cpu;
}

CPUState *mon_get_cpu(Monitor *mon)
{
    return mon_get_cpu_sync(mon, true);
}

CPUArchState *mon_get_cpu_env(Monitor *mon)
{
    CPUState *cs = mon_get_cpu(mon);

    return cs ? cs->env_ptr : NULL;
}

int monitor_get_cpu_index(Monitor *mon)
{
    CPUState *cs = mon_get_cpu_sync(mon, false);

    return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
}

void hmp_info_registers(Monitor *mon, const QDict *qdict)
{
    bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
    int vcpu = qdict_get_try_int(qdict, "vcpu", -1);
    CPUState *cs;

    if (all_cpus) {
        CPU_FOREACH(cs) {
            monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
            cpu_dump_state(cs, NULL, CPU_DUMP_FPU);
        }
    } else {
        cs = vcpu >= 0 ? qemu_get_cpu(vcpu) : mon_get_cpu(mon);

        if (!cs) {
            if (vcpu >= 0) {
                monitor_printf(mon, "CPU#%d not available\n", vcpu);
            } else {
                monitor_printf(mon, "No CPU available\n");
            }
            return;
        }

        monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
        cpu_dump_state(cs, NULL, CPU_DUMP_FPU);
    }
}

static void memory_dump(Monitor *mon, int count, int format, int wsize,
                        hwaddr addr, int is_physical)
{
    int l, line_size, i, max_digits, len;
    uint8_t buf[16];
    uint64_t v;
    CPUState *cs = mon_get_cpu(mon);

    if (!cs && (format == 'i' || !is_physical)) {
        monitor_printf(mon, "Can not dump without CPU\n");
        return;
    }

    if (format == 'i') {
        monitor_disas(mon, cs, addr, count, is_physical);
        return;
    }

    len = wsize * count;
    if (wsize == 1) {
        line_size = 8;
    } else {
        line_size = 16;
    }
    max_digits = 0;

    switch(format) {
    case 'o':
        max_digits = DIV_ROUND_UP(wsize * 8, 3);
        break;
    default:
    case 'x':
        max_digits = (wsize * 8) / 4;
        break;
    case 'u':
    case 'd':
        max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
        break;
    case 'c':
        wsize = 1;
        break;
    }

    while (len > 0) {
        if (is_physical) {
            monitor_printf(mon, HWADDR_FMT_plx ":", addr);
        } else {
            monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
        }
        l = len;
        if (l > line_size)
            l = line_size;
        if (is_physical) {
            AddressSpace *as = cs ? cs->as : &address_space_memory;
            MemTxResult r = address_space_read(as, addr,
                                               MEMTXATTRS_UNSPECIFIED, buf, l);
            if (r != MEMTX_OK) {
                monitor_printf(mon, " Cannot access memory\n");
                break;
            }
        } else {
            if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
                monitor_printf(mon, " Cannot access memory\n");
                break;
            }
        }
        i = 0;
        while (i < l) {
            switch(wsize) {
            default:
            case 1:
                v = ldub_p(buf + i);
                break;
            case 2:
                v = lduw_p(buf + i);
                break;
            case 4:
                v = (uint32_t)ldl_p(buf + i);
                break;
            case 8:
                v = ldq_p(buf + i);
                break;
            }
            monitor_printf(mon, " ");
            switch(format) {
            case 'o':
                monitor_printf(mon, "%#*" PRIo64, max_digits, v);
                break;
            case 'x':
                monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
                break;
            case 'u':
                monitor_printf(mon, "%*" PRIu64, max_digits, v);
                break;
            case 'd':
                monitor_printf(mon, "%*" PRId64, max_digits, v);
                break;
            case 'c':
                monitor_printc(mon, v);
                break;
            }
            i += wsize;
        }
        monitor_printf(mon, "\n");
        addr += l;
        len -= l;
    }
}

void hmp_memory_dump(Monitor *mon, const QDict *qdict)
{
    int count = qdict_get_int(qdict, "count");
    int format = qdict_get_int(qdict, "format");
    int size = qdict_get_int(qdict, "size");
    target_long addr = qdict_get_int(qdict, "addr");

    memory_dump(mon, count, format, size, addr, 0);
}

void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
{
    int count = qdict_get_int(qdict, "count");
    int format = qdict_get_int(qdict, "format");
    int size = qdict_get_int(qdict, "size");
    hwaddr addr = qdict_get_int(qdict, "addr");

    memory_dump(mon, count, format, size, addr, 1);
}

void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, uint64_t size, Error **errp)
{
    Int128 gpa_region_size;
    MemoryRegionSection mrs = memory_region_find(get_system_memory(),
                                                 addr, size);

    if (!mrs.mr) {
        error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
        return NULL;
    }

    if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
        error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
        memory_region_unref(mrs.mr);
        return NULL;
    }

    gpa_region_size = int128_make64(size);
    if (int128_lt(mrs.size, gpa_region_size)) {
        error_setg(errp, "Size of memory region at 0x%" HWADDR_PRIx
                   " exceeded.", addr);
        memory_region_unref(mrs.mr);
        return NULL;
    }

    *p_mr = mrs.mr;
    return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
}

void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
{
    hwaddr addr = qdict_get_int(qdict, "addr");
    Error *local_err = NULL;
    MemoryRegion *mr = NULL;
    void *ptr;

    ptr = gpa2hva(&mr, addr, 1, &local_err);
    if (local_err) {
        error_report_err(local_err);
        return;
    }

    monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
                   " (%s) is %p\n",
                   addr, mr->name, ptr);

    memory_region_unref(mr);
}

void hmp_gva2gpa(Monitor *mon, const QDict *qdict)
{
    target_ulong addr = qdict_get_int(qdict, "addr");
    MemTxAttrs attrs;
    CPUState *cs = mon_get_cpu(mon);
    hwaddr gpa;

    if (!cs) {
        monitor_printf(mon, "No cpu\n");
        return;
    }

    gpa  = cpu_get_phys_page_attrs_debug(cs, addr & TARGET_PAGE_MASK, &attrs);
    if (gpa == -1) {
        monitor_printf(mon, "Unmapped\n");
    } else {
        monitor_printf(mon, "gpa: %#" HWADDR_PRIx "\n",
                       gpa + (addr & ~TARGET_PAGE_MASK));
    }
}

#ifdef CONFIG_LINUX
static uint64_t vtop(void *ptr, Error **errp)
{
    uint64_t pinfo;
    uint64_t ret = -1;
    uintptr_t addr = (uintptr_t) ptr;
    uintptr_t pagesize = qemu_real_host_page_size();
    off_t offset = addr / pagesize * sizeof(pinfo);
    int fd;

    fd = open("/proc/self/pagemap", O_RDONLY);
    if (fd == -1) {
        error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
        return -1;
    }

    /* Force copy-on-write if necessary.  */
    qatomic_add((uint8_t *)ptr, 0);

    if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
        error_setg_errno(errp, errno, "Cannot read pagemap");
        goto out;
    }
    if ((pinfo & (1ull << 63)) == 0) {
        error_setg(errp, "Page not present");
        goto out;
    }
    ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));

out:
    close(fd);
    return ret;
}

void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
{
    hwaddr addr = qdict_get_int(qdict, "addr");
    Error *local_err = NULL;
    MemoryRegion *mr = NULL;
    void *ptr;
    uint64_t physaddr;

    ptr = gpa2hva(&mr, addr, 1, &local_err);
    if (local_err) {
        error_report_err(local_err);
        return;
    }

    physaddr = vtop(ptr, &local_err);
    if (local_err) {
        error_report_err(local_err);
    } else {
        monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
                       " (%s) is 0x%" PRIx64 "\n",
                       addr, mr->name, (uint64_t) physaddr);
    }

    memory_region_unref(mr);
}
#endif
Commit	Line	Data
e2245566 MA	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