starred/qemu
1
0
Fork 0
mirror of https://github.com/qemu/qemu.git synced 2026-07-08 17:46:10 +00:00
Code Issues 380 Packages Projects Releases Wiki Activity

monitor: replace 'common' with 'parent_obj' in MonitorHMP

Browse Source 
The field name 'parent_obj' is standard practice for QOM structs
so align the HMP monitor.

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Reviewed-by: Dr. David Alan Gilbert <dave@treblig.org>
Tested-by: Peter Krempa <pkrempa@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-ID: <20260706135824.2623960-3-berrange@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
This commit is contained in:
Daniel P. Berrangé
2026-07-06 14:57:50 +01:00
committed by Markus Armbruster
parent 9c3b2c9db5
commit 8b5ca42730
6 changed files with 34 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
monitor/hmp-cmds.c
View File

@@ -287,7 +287,7 @@ void hmp_info_sync_profile(Monitor *mon, const QDict *qdict)
void hmp_info_history(Monitor *mon, const QDict *qdict) void hmp_info_history(Monitor *mon, const QDict *qdict)
{ {
MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common); MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, parent_obj);
int i; int i;
const char *str; const char *str;

43
monitor/hmp.c
View File

@@ -48,9 +48,9 @@ static void monitor_command_cb(void *opaque, const char *cmdline,
{ {
MonitorHMP *mon = opaque; MonitorHMP *mon = opaque;
monitor_suspend(&mon->common); monitor_suspend(&mon->parent_obj);
handle_hmp_command(mon, cmdline); handle_hmp_command(mon, cmdline);
monitor_resume(&mon->common); monitor_resume(&mon->parent_obj);
} }
void monitor_read_command(MonitorHMP *mon, int show_prompt) void monitor_read_command(MonitorHMP *mon, int show_prompt)
@@ -73,7 +73,7 @@ int monitor_read_password(MonitorHMP *mon, ReadLineFunc *readline_func,
/* prompt is printed on return from the command handler */ /* prompt is printed on return from the command handler */
return 0; return 0;
} else { } else {
monitor_printf(&mon->common, monitor_printf(&mon->parent_obj,
"terminal does not support password prompting\n"); "terminal does not support password prompting\n");
return -ENOTTY; return -ENOTTY;
} }
@@ -695,7 +695,7 @@ static const HMPCommand *monitor_parse_command(MonitorHMP *hmp_mon,
const char **cmdp, const char **cmdp,
HMPCommand *table) HMPCommand *table)
{ {
Monitor *mon = &hmp_mon->common; Monitor *mon = &hmp_mon->parent_obj;
const char *p; const char *p;
const HMPCommand *cmd; const HMPCommand *cmd;
char cmdname[256]; char cmdname[256];
@@ -1188,35 +1188,37 @@ void handle_hmp_command(MonitorHMP *mon, const char *cmdline)
if (!cmd->cmd && !cmd->cmd_info_hrt) { if (!cmd->cmd && !cmd->cmd_info_hrt) {
/* FIXME: is it useful to try autoload modules here ??? */ /* FIXME: is it useful to try autoload modules here ??? */
monitor_printf(&mon->common, "Command \"%.*s\" is not available.\n", monitor_printf(&mon->parent_obj, "Command \"%.*s\" is not available.\n",
(int)(cmdline - cmd_start), cmd_start); (int)(cmdline - cmd_start), cmd_start);
return; return;
} }
qdict = monitor_parse_arguments(&mon->common, &cmdline, cmd); qdict = monitor_parse_arguments(&mon->parent_obj, &cmdline, cmd);
if (!qdict) { if (!qdict) {
while (cmdline > cmd_start && qemu_isspace(cmdline[-1])) { while (cmdline > cmd_start && qemu_isspace(cmdline[-1])) {
cmdline--; cmdline--;
} }
monitor_printf(&mon->common, "Try \"help %.*s\" for more information\n", monitor_printf(&mon->parent_obj,
"Try \"help %.*s\" for more information\n",
(int)(cmdline - cmd_start), cmd_start); (int)(cmdline - cmd_start), cmd_start);
return; return;
} }
if (!cmd->coroutine) { if (!cmd->coroutine) {
/* old_mon is non-NULL when called from qmp_human_monitor_command() */ /* old_mon is non-NULL when called from qmp_human_monitor_command() */
Monitor *old_mon = monitor_set_cur(qemu_coroutine_self(), &mon->common); Monitor *old_mon = monitor_set_cur(qemu_coroutine_self(),
handle_hmp_command_exec(&mon->common, cmd, qdict); &mon->parent_obj);
handle_hmp_command_exec(&mon->parent_obj, cmd, qdict);
monitor_set_cur(qemu_coroutine_self(), old_mon); monitor_set_cur(qemu_coroutine_self(), old_mon);
} else { } else {
HandleHmpCommandCo data = { HandleHmpCommandCo data = {
.mon = &mon->common, .mon = &mon->parent_obj,
.cmd = cmd, .cmd = cmd,
.qdict = qdict, .qdict = qdict,
.done = false, .done = false,
}; };
Coroutine *co = qemu_coroutine_create(handle_hmp_command_co, &data); Coroutine *co = qemu_coroutine_create(handle_hmp_command_co, &data);
monitor_set_cur(co, &mon->common); monitor_set_cur(co, &mon->parent_obj);
aio_co_enter(qemu_get_aio_context(), co); aio_co_enter(qemu_get_aio_context(), co);
AIO_WAIT_WHILE_UNLOCKED(NULL, !data.done); AIO_WAIT_WHILE_UNLOCKED(NULL, !data.done);
} }
@@ -1434,7 +1436,7 @@ cleanup:
static void monitor_read(void *opaque, const uint8_t *buf, int size) static void monitor_read(void *opaque, const uint8_t *buf, int size)
{ {
MonitorHMP *mon = container_of(opaque, MonitorHMP, common); MonitorHMP *mon = container_of(opaque, MonitorHMP, parent_obj);
int i; int i;
if (mon->rs) { if (mon->rs) {
@@ -1443,7 +1445,7 @@ static void monitor_read(void *opaque, const uint8_t *buf, int size)
} }
} else { } else {
if (size == 0 || buf[size - 1] != 0) { if (size == 0 || buf[size - 1] != 0) {
monitor_printf(&mon->common, "corrupted command\n"); monitor_printf(&mon->parent_obj, "corrupted command\n");
} else { } else {
handle_hmp_command(mon, (char *)buf); handle_hmp_command(mon, (char *)buf);
} }
@@ -1512,26 +1514,26 @@ static void G_GNUC_PRINTF(2, 3) monitor_readline_printf(void *opaque,
MonitorHMP *mon = opaque; MonitorHMP *mon = opaque;
va_list ap; va_list ap;
va_start(ap, fmt); va_start(ap, fmt);
monitor_vprintf(&mon->common, fmt, ap); monitor_vprintf(&mon->parent_obj, fmt, ap);
va_end(ap); va_end(ap);
} }
static void monitor_readline_flush(void *opaque) static void monitor_readline_flush(void *opaque)
{ {
MonitorHMP *mon = opaque; MonitorHMP *mon = opaque;
monitor_flush(&mon->common); monitor_flush(&mon->parent_obj);
} }
void monitor_init_hmp(Chardev *chr, bool use_readline, Error **errp) void monitor_init_hmp(Chardev *chr, bool use_readline, Error **errp)
{ {
MonitorHMP *mon = g_new0(MonitorHMP, 1); MonitorHMP *mon = g_new0(MonitorHMP, 1);
if (!qemu_chr_fe_init(&mon->common.chr, chr, errp)) { if (!qemu_chr_fe_init(&mon->parent_obj.chr, chr, errp)) {
g_free(mon); g_free(mon);
return; return;
} }
monitor_data_init(&mon->common, false, false, false); monitor_data_init(&mon->parent_obj, false, false, false);
mon->use_readline = use_readline; mon->use_readline = use_readline;
if (mon->use_readline) { if (mon->use_readline) {
@@ -1542,9 +1544,10 @@ void monitor_init_hmp(Chardev *chr, bool use_readline, Error **errp)
monitor_read_command(mon, 0); monitor_read_command(mon, 0);
} }
qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read, monitor_read, qemu_chr_fe_set_handlers(&mon->parent_obj.chr,
monitor_event, NULL, &mon->common, NULL, true); monitor_can_read, monitor_read, monitor_event,
monitor_list_append(&mon->common); NULL, &mon->parent_obj, NULL, true);
monitor_list_append(&mon->parent_obj);
} }
/** /**

2
monitor/monitor-internal.h
View File

@@ -128,7 +128,7 @@ struct Monitor {
}; };
struct MonitorHMP { struct MonitorHMP {
Monitor common; Monitor parent_obj;
bool use_readline; bool use_readline;
/* /*
* State used only in the thread "owning" the monitor. * State used only in the thread "owning" the monitor.

6
monitor/monitor.c
View File

@@ -132,7 +132,7 @@ static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
return false; return false;
} }
return !monitor_uses_readline(container_of(mon, MonitorHMP, common)); return !monitor_uses_readline(container_of(mon, MonitorHMP, parent_obj));
} }
static gboolean monitor_unblocked(void *do_not_use, GIOCondition cond, static gboolean monitor_unblocked(void *do_not_use, GIOCondition cond,
@@ -542,7 +542,7 @@ static void monitor_accept_input(void *opaque)
qemu_mutex_lock(&mon->mon_lock); qemu_mutex_lock(&mon->mon_lock);
if (!monitor_is_qmp(mon) && mon->reset_seen) { if (!monitor_is_qmp(mon) && mon->reset_seen) {
MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common); MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, parent_obj);
assert(hmp_mon->rs); assert(hmp_mon->rs);
readline_restart(hmp_mon->rs); readline_restart(hmp_mon->rs);
qemu_mutex_unlock(&mon->mon_lock); qemu_mutex_unlock(&mon->mon_lock);
@@ -627,7 +627,7 @@ void monitor_data_destroy(Monitor *mon)
if (monitor_is_qmp(mon)) { if (monitor_is_qmp(mon)) {
monitor_data_destroy_qmp(container_of(mon, MonitorQMP, common)); monitor_data_destroy_qmp(container_of(mon, MonitorQMP, common));
} else { } else {
readline_free(container_of(mon, MonitorHMP, common)->rs); readline_free(container_of(mon, MonitorHMP, parent_obj)->rs);
} }
g_string_free(mon->outbuf, true); g_string_free(mon->outbuf, true);
qemu_mutex_destroy(&mon->mon_lock); qemu_mutex_destroy(&mon->mon_lock);

10
monitor/qmp-cmds.c
View File

@@ -168,10 +168,10 @@ char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
char *output = NULL; char *output = NULL;
MonitorHMP hmp = {}; MonitorHMP hmp = {};
monitor_data_init(&hmp.common, false, true, false); monitor_data_init(&hmp.parent_obj, false, true, false);
if (has_cpu_index) { if (has_cpu_index) {
int ret = monitor_set_cpu(&hmp.common, cpu_index); int ret = monitor_set_cpu(&hmp.parent_obj, cpu_index);
if (ret < 0) { if (ret < 0) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index", error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
"a CPU number"); "a CPU number");
@@ -181,12 +181,12 @@ char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
handle_hmp_command(&hmp, command_line); handle_hmp_command(&hmp, command_line);
WITH_QEMU_LOCK_GUARD(&hmp.common.mon_lock) { WITH_QEMU_LOCK_GUARD(&hmp.parent_obj.mon_lock) {
output = g_strdup(hmp.common.outbuf->str); output = g_strdup(hmp.parent_obj.outbuf->str);
} }
out: out:
monitor_data_destroy(&hmp.common); monitor_data_destroy(&hmp.parent_obj);
return output; return output;
} }

2
ui/ui-hmp-cmds.c
View File

@@ -343,7 +343,7 @@ void hmp_change_vnc(Monitor *mon, const char *device, const char *target,
return; return;
} }
if (!arg) { if (!arg) {
MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common); MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, parent_obj);
monitor_read_password(hmp_mon, hmp_change_read_arg, NULL); monitor_read_password(hmp_mon, hmp_change_read_arg, NULL);
} else { } else {
qmp_change_vnc_password(arg, errp); qmp_change_vnc_password(arg, errp);