Diff for /qemu/monitor.c between versions 1.1.1.15 and 1.1.1.16

version 1.1.1.15, 2018/04/24 18:56:21 version 1.1.1.16, 2018/04/24 19:17:26
Line 57 Line 57
 #include "json-parser.h"  #include "json-parser.h"
 #include "osdep.h"  #include "osdep.h"
 #include "cpu.h"  #include "cpu.h"
 #ifdef CONFIG_SIMPLE_TRACE  
 #include "trace.h"  #include "trace.h"
   #include "trace/control.h"
   #ifdef CONFIG_TRACE_SIMPLE
   #include "trace/simple.h"
 #endif  #endif
 #include "ui/qemu-spice.h"  #include "ui/qemu-spice.h"
   #include "memory.h"
   #include "qmp-commands.h"
   #include "hmp.h"
   
   /* for pic/irq_info */
   #if defined(TARGET_SPARC)
   #include "hw/sun4m.h"
   #endif
   #include "hw/lm32_pic.h"
   
 //#define DEBUG  //#define DEBUG
 //#define DEBUG_COMPLETION  //#define DEBUG_COMPLETION
Line 112  typedef struct mon_cmd_t { Line 123  typedef struct mon_cmd_t {
     void (*user_print)(Monitor *mon, const QObject *data);      void (*user_print)(Monitor *mon, const QObject *data);
     union {      union {
         void (*info)(Monitor *mon);          void (*info)(Monitor *mon);
         void (*info_new)(Monitor *mon, QObject **ret_data);  
         int  (*info_async)(Monitor *mon, MonitorCompletion *cb, void *opaque);  
         void (*cmd)(Monitor *mon, const QDict *qdict);          void (*cmd)(Monitor *mon, const QDict *qdict);
         int  (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);          int  (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
         int  (*cmd_async)(Monitor *mon, const QDict *params,          int  (*cmd_async)(Monitor *mon, const QDict *params,
                           MonitorCompletion *cb, void *opaque);                            MonitorCompletion *cb, void *opaque);
     } mhandler;      } mhandler;
       bool qapi;
     int flags;      int flags;
 } mon_cmd_t;  } mon_cmd_t;
   
Line 189  static inline int mon_print_count_get(co Line 199  static inline int mon_print_count_get(co
   
 static QLIST_HEAD(mon_list, Monitor) mon_list;  static QLIST_HEAD(mon_list, Monitor) mon_list;
   
 static const mon_cmd_t mon_cmds[];  static mon_cmd_t mon_cmds[];
 static const mon_cmd_t info_cmds[];  static mon_cmd_t info_cmds[];
   
 static const mon_cmd_t qmp_cmds[];  static const mon_cmd_t qmp_cmds[];
 static const mon_cmd_t qmp_query_cmds[];  
   
 Monitor *cur_mon;  Monitor *cur_mon;
 Monitor *default_mon;  Monitor *default_mon;
Line 247  static int monitor_read_password(Monitor Line 256  static int monitor_read_password(Monitor
 void monitor_flush(Monitor *mon)  void monitor_flush(Monitor *mon)
 {  {
     if (mon && mon->outbuf_index != 0 && !mon->mux_out) {      if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
         qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);          qemu_chr_fe_write(mon->chr, mon->outbuf, mon->outbuf_index);
         mon->outbuf_index = 0;          mon->outbuf_index = 0;
     }      }
 }  }
Line 367  static void monitor_protocol_emitter(Mon Line 376  static void monitor_protocol_emitter(Mon
 {  {
     QDict *qmp;      QDict *qmp;
   
       trace_monitor_protocol_emitter(mon);
   
     qmp = qdict_new();      qmp = qdict_new();
   
     if (!monitor_has_error(mon)) {      if (!monitor_has_error(mon)) {
Line 500  static int do_qmp_capabilities(Monitor * Line 511  static int do_qmp_capabilities(Monitor *
     return 0;      return 0;
 }  }
   
 static int mon_set_cpu(int cpu_index);  
 static void handle_user_command(Monitor *mon, const char *cmdline);  static void handle_user_command(Monitor *mon, const char *cmdline);
   
 static int do_hmp_passthrough(Monitor *mon, const QDict *params,  static int do_hmp_passthrough(Monitor *mon, const QDict *params,
Line 518  static int do_hmp_passthrough(Monitor *m Line 528  static int do_hmp_passthrough(Monitor *m
     cur_mon = &hmp;      cur_mon = &hmp;
   
     if (qdict_haskey(params, "cpu-index")) {      if (qdict_haskey(params, "cpu-index")) {
         ret = mon_set_cpu(qdict_get_int(params, "cpu-index"));          ret = monitor_set_cpu(qdict_get_int(params, "cpu-index"));
         if (ret < 0) {          if (ret < 0) {
             cur_mon = old_mon;              cur_mon = old_mon;
             qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index", "a CPU number");              qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index", "a CPU number");
Line 592  static void do_help_cmd(Monitor *mon, co Line 602  static void do_help_cmd(Monitor *mon, co
     help_cmd(mon, qdict_get_try_str(qdict, "name"));      help_cmd(mon, qdict_get_try_str(qdict, "name"));
 }  }
   
 #ifdef CONFIG_SIMPLE_TRACE  static void do_trace_event_set_state(Monitor *mon, const QDict *qdict)
 static void do_change_trace_event_state(Monitor *mon, const QDict *qdict)  
 {  {
     const char *tp_name = qdict_get_str(qdict, "name");      const char *tp_name = qdict_get_str(qdict, "name");
     bool new_state = qdict_get_bool(qdict, "option");      bool new_state = qdict_get_bool(qdict, "option");
     int ret = st_change_trace_event_state(tp_name, new_state);      int ret = trace_event_set_state(tp_name, new_state);
   
     if (!ret) {      if (!ret) {
         monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);          monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);
     }      }
 }  }
   
   #ifdef CONFIG_TRACE_SIMPLE
 static void do_trace_file(Monitor *mon, const QDict *qdict)  static void do_trace_file(Monitor *mon, const QDict *qdict)
 {  {
     const char *op = qdict_get_try_str(qdict, "op");      const char *op = qdict_get_try_str(qdict, "op");
Line 636  static void user_monitor_complete(void * Line 646  static void user_monitor_complete(void *
         data->user_print(data->mon, ret_data);          data->user_print(data->mon, ret_data);
     }      }
     monitor_resume(data->mon);      monitor_resume(data->mon);
     qemu_free(data);      g_free(data);
 }  }
   
 static void qmp_monitor_complete(void *opaque, QObject *ret_data)  static void qmp_monitor_complete(void *opaque, QObject *ret_data)
Line 650  static int qmp_async_cmd_handler(Monitor Line 660  static int qmp_async_cmd_handler(Monitor
     return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);      return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
 }  }
   
 static void qmp_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)  
 {  
     cmd->mhandler.info_async(mon, qmp_monitor_complete, mon);  
 }  
   
 static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,  static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
                                    const QDict *params)                                     const QDict *params)
 {  {
     int ret;      int ret;
   
     MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));      MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
     cb_data->mon = mon;      cb_data->mon = mon;
     cb_data->user_print = cmd->user_print;      cb_data->user_print = cmd->user_print;
     monitor_suspend(mon);      monitor_suspend(mon);
Line 668  static void user_async_cmd_handler(Monit Line 673  static void user_async_cmd_handler(Monit
                                   user_monitor_complete, cb_data);                                    user_monitor_complete, cb_data);
     if (ret < 0) {      if (ret < 0) {
         monitor_resume(mon);          monitor_resume(mon);
         qemu_free(cb_data);          g_free(cb_data);
     }  
 }  
   
 static void user_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)  
 {  
     int ret;  
   
     MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));  
     cb_data->mon = mon;  
     cb_data->user_print = cmd->user_print;  
     monitor_suspend(mon);  
     ret = cmd->mhandler.info_async(mon, user_monitor_complete, cb_data);  
     if (ret < 0) {  
         monitor_resume(mon);  
         qemu_free(cb_data);  
     }      }
 }  }
   
Line 705  static void do_info(Monitor *mon, const  Line 695  static void do_info(Monitor *mon, const 
         goto help;          goto help;
     }      }
   
     if (handler_is_async(cmd)) {      cmd->mhandler.info(mon);
         user_async_info_handler(mon, cmd);  
     } else if (handler_is_qobject(cmd)) {  
         QObject *info_data = NULL;  
   
         cmd->mhandler.info_new(mon, &info_data);  
         if (info_data) {  
             cmd->user_print(mon, info_data);  
             qobject_decref(info_data);  
         }  
     } else {  
         cmd->mhandler.info(mon);  
     }  
   
     return;      return;
   
 help:  help:
     help_cmd(mon, "info");      help_cmd(mon, "info");
 }  }
   
 static void do_info_version_print(Monitor *mon, const QObject *data)  CommandInfoList *qmp_query_commands(Error **errp)
 {  {
     QDict *qdict;      CommandInfoList *info, *cmd_list = NULL;
     QDict *qemu;  
   
     qdict = qobject_to_qdict(data);  
     qemu = qdict_get_qdict(qdict, "qemu");  
   
     monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",  
                   qdict_get_int(qemu, "major"),  
                   qdict_get_int(qemu, "minor"),  
                   qdict_get_int(qemu, "micro"),  
                   qdict_get_str(qdict, "package"));  
 }  
   
 static void do_info_version(Monitor *mon, QObject **ret_data)  
 {  
     const char *version = QEMU_VERSION;  
     int major = 0, minor = 0, micro = 0;  
     char *tmp;  
   
     major = strtol(version, &tmp, 10);  
     tmp++;  
     minor = strtol(tmp, &tmp, 10);  
     tmp++;  
     micro = strtol(tmp, &tmp, 10);  
   
     *ret_data = qobject_from_jsonf("{ 'qemu': { 'major': %d, 'minor': %d, \  
         'micro': %d }, 'package': %s }", major, minor, micro, QEMU_PKGVERSION);  
 }  
   
 static void do_info_name_print(Monitor *mon, const QObject *data)  
 {  
     QDict *qdict;  
   
     qdict = qobject_to_qdict(data);  
     if (qdict_size(qdict) == 0) {  
         return;  
     }  
   
     monitor_printf(mon, "%s\n", qdict_get_str(qdict, "name"));  
 }  
   
 static void do_info_name(Monitor *mon, QObject **ret_data)  
 {  
     *ret_data = qemu_name ? qobject_from_jsonf("{'name': %s }", qemu_name) :  
                             qobject_from_jsonf("{}");  
 }  
   
 static QObject *get_cmd_dict(const char *name)  
 {  
     const char *p;  
   
     /* Remove '|' from some commands */  
     p = strchr(name, '|');  
     if (p) {  
         p++;  
     } else {  
         p = name;  
     }  
   
     return qobject_from_jsonf("{ 'name': %s }", p);  
 }  
   
 static void do_info_commands(Monitor *mon, QObject **ret_data)  
 {  
     QList *cmd_list;  
     const mon_cmd_t *cmd;      const mon_cmd_t *cmd;
   
     cmd_list = qlist_new();  
   
     for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {      for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
         qlist_append_obj(cmd_list, get_cmd_dict(cmd->name));          info = g_malloc0(sizeof(*info));
     }          info->value = g_malloc0(sizeof(*info->value));
           info->value->name = g_strdup(cmd->name);
   
     for (cmd = qmp_query_cmds; cmd->name != NULL; cmd++) {          info->next = cmd_list;
         char buf[128];          cmd_list = info;
         snprintf(buf, sizeof(buf), "query-%s", cmd->name);  
         qlist_append_obj(cmd_list, get_cmd_dict(buf));  
     }      }
   
     *ret_data = QOBJECT(cmd_list);      return cmd_list;
 }  
   
 static void do_info_uuid_print(Monitor *mon, const QObject *data)  
 {  
     monitor_printf(mon, "%s\n", qdict_get_str(qobject_to_qdict(data), "UUID"));  
 }  
   
 static void do_info_uuid(Monitor *mon, QObject **ret_data)  
 {  
     char uuid[64];  
   
     snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],  
                    qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],  
                    qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],  
                    qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],  
                    qemu_uuid[14], qemu_uuid[15]);  
     *ret_data = qobject_from_jsonf("{ 'UUID': %s }", uuid);  
 }  }
   
 /* get the current CPU defined by the user */  /* set the current CPU defined by the user */
 static int mon_set_cpu(int cpu_index)  int monitor_set_cpu(int cpu_index)
 {  {
     CPUState *env;      CPUState *env;
   
Line 843  static int mon_set_cpu(int cpu_index) Line 736  static int mon_set_cpu(int cpu_index)
 static CPUState *mon_get_cpu(void)  static CPUState *mon_get_cpu(void)
 {  {
     if (!cur_mon->mon_cpu) {      if (!cur_mon->mon_cpu) {
         mon_set_cpu(0);          monitor_set_cpu(0);
     }      }
     cpu_synchronize_state(cur_mon->mon_cpu);      cpu_synchronize_state(cur_mon->mon_cpu);
     return cur_mon->mon_cpu;      return cur_mon->mon_cpu;
 }  }
   
   int monitor_get_cpu_index(void)
   {
       return mon_get_cpu()->cpu_index;
   }
   
 static void do_info_registers(Monitor *mon)  static void do_info_registers(Monitor *mon)
 {  {
     CPUState *env;      CPUState *env;
Line 862  static void do_info_registers(Monitor *m Line 760  static void do_info_registers(Monitor *m
 #endif  #endif
 }  }
   
 static void print_cpu_iter(QObject *obj, void *opaque)  
 {  
     QDict *cpu;  
     int active = ' ';  
     Monitor *mon = opaque;  
   
     assert(qobject_type(obj) == QTYPE_QDICT);  
     cpu = qobject_to_qdict(obj);  
   
     if (qdict_get_bool(cpu, "current")) {  
         active = '*';  
     }  
   
     monitor_printf(mon, "%c CPU #%d: ", active, (int)qdict_get_int(cpu, "CPU"));  
   
 #if defined(TARGET_I386)  
     monitor_printf(mon, "pc=0x" TARGET_FMT_lx,  
                    (target_ulong) qdict_get_int(cpu, "pc"));  
 #elif defined(TARGET_PPC)  
     monitor_printf(mon, "nip=0x" TARGET_FMT_lx,  
                    (target_long) qdict_get_int(cpu, "nip"));  
 #elif defined(TARGET_SPARC)  
     monitor_printf(mon, "pc=0x " TARGET_FMT_lx,  
                    (target_long) qdict_get_int(cpu, "pc"));  
     monitor_printf(mon, "npc=0x" TARGET_FMT_lx,  
                    (target_long) qdict_get_int(cpu, "npc"));  
 #elif defined(TARGET_MIPS)  
     monitor_printf(mon, "PC=0x" TARGET_FMT_lx,  
                    (target_long) qdict_get_int(cpu, "PC"));  
 #endif  
   
     if (qdict_get_bool(cpu, "halted")) {  
         monitor_printf(mon, " (halted)");  
     }  
   
     monitor_printf(mon, " thread_id=%" PRId64 " ",  
                    qdict_get_int(cpu, "thread_id"));  
   
     monitor_printf(mon, "\n");  
 }  
   
 static void monitor_print_cpus(Monitor *mon, const QObject *data)  
 {  
     QList *cpu_list;  
   
     assert(qobject_type(data) == QTYPE_QLIST);  
     cpu_list = qobject_to_qlist(data);  
     qlist_iter(cpu_list, print_cpu_iter, mon);  
 }  
   
 static void do_info_cpus(Monitor *mon, QObject **ret_data)  
 {  
     CPUState *env;  
     QList *cpu_list;  
   
     cpu_list = qlist_new();  
   
     /* just to set the default cpu if not already done */  
     mon_get_cpu();  
   
     for(env = first_cpu; env != NULL; env = env->next_cpu) {  
         QDict *cpu;  
         QObject *obj;  
   
         cpu_synchronize_state(env);  
   
         obj = qobject_from_jsonf("{ 'CPU': %d, 'current': %i, 'halted': %i }",  
                                  env->cpu_index, env == mon->mon_cpu,  
                                  env->halted);  
   
         cpu = qobject_to_qdict(obj);  
   
 #if defined(TARGET_I386)  
         qdict_put(cpu, "pc", qint_from_int(env->eip + env->segs[R_CS].base));  
 #elif defined(TARGET_PPC)  
         qdict_put(cpu, "nip", qint_from_int(env->nip));  
 #elif defined(TARGET_SPARC)  
         qdict_put(cpu, "pc", qint_from_int(env->pc));  
         qdict_put(cpu, "npc", qint_from_int(env->npc));  
 #elif defined(TARGET_MIPS)  
         qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));  
 #endif  
         qdict_put(cpu, "thread_id", qint_from_int(env->thread_id));  
   
         qlist_append(cpu_list, cpu);  
     }  
   
     *ret_data = QOBJECT(cpu_list);  
 }  
   
 static int do_cpu_set(Monitor *mon, const QDict *qdict, QObject **ret_data)  
 {  
     int index = qdict_get_int(qdict, "index");  
     if (mon_set_cpu(index) < 0) {  
         qerror_report(QERR_INVALID_PARAMETER_VALUE, "index",  
                       "a CPU number");  
         return -1;  
     }  
     return 0;  
 }  
   
 static void do_info_jit(Monitor *mon)  static void do_info_jit(Monitor *mon)
 {  {
     dump_exec_info((FILE *)mon, monitor_fprintf);      dump_exec_info((FILE *)mon, monitor_fprintf);
Line 996  static void do_info_cpu_stats(Monitor *m Line 793  static void do_info_cpu_stats(Monitor *m
 }  }
 #endif  #endif
   
 #if defined(CONFIG_SIMPLE_TRACE)  #if defined(CONFIG_TRACE_SIMPLE)
 static void do_info_trace(Monitor *mon)  static void do_info_trace(Monitor *mon)
 {  {
     st_print_trace((FILE *)mon, &monitor_fprintf);      st_print_trace((FILE *)mon, &monitor_fprintf);
 }  }
   
 static void do_info_trace_events(Monitor *mon)  
 {  
     st_print_trace_events((FILE *)mon, &monitor_fprintf);  
 }  
 #endif  #endif
   
 /**  static void do_trace_print_events(Monitor *mon)
  * do_quit(): Quit QEMU execution  
  */  
 static int do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)  
 {  {
     monitor_suspend(mon);      trace_print_events((FILE *)mon, &monitor_fprintf);
     no_shutdown = 0;  
     qemu_system_shutdown_request();  
   
     return 0;  
 }  }
   
 #ifdef CONFIG_VNC  #ifdef CONFIG_VNC
Line 1219  static int add_graphics_client(Monitor * Line 1004  static int add_graphics_client(Monitor *
     return -1;      return -1;
 }  }
   
 static int client_migrate_info(Monitor *mon, const QDict *qdict, QObject **ret_data)  static int client_migrate_info(Monitor *mon, const QDict *qdict,
                                  MonitorCompletion cb, void *opaque)
 {  {
     const char *protocol = qdict_get_str(qdict, "protocol");      const char *protocol = qdict_get_str(qdict, "protocol");
     const char *hostname = qdict_get_str(qdict, "hostname");      const char *hostname = qdict_get_str(qdict, "hostname");
Line 1234  static int client_migrate_info(Monitor * Line 1020  static int client_migrate_info(Monitor *
             return -1;              return -1;
         }          }
   
         ret = qemu_spice_migrate_info(hostname, port, tls_port, subject);          ret = qemu_spice_migrate_info(hostname, port, tls_port, subject,
                                         cb, opaque);
         if (ret != 0) {          if (ret != 0) {
             qerror_report(QERR_UNDEFINED_ERROR);              qerror_report(QERR_UNDEFINED_ERROR);
             return -1;              return -1;
Line 1286  static void do_singlestep(Monitor *mon,  Line 1073  static void do_singlestep(Monitor *mon, 
     }      }
 }  }
   
 /**  
  * do_stop(): Stop VM execution  
  */  
 static int do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)  
 {  
     vm_stop(VMSTOP_USER);  
     return 0;  
 }  
   
 static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);  static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
   
 struct bdrv_iterate_context {  struct bdrv_iterate_context {
Line 1302  struct bdrv_iterate_context { Line 1080  struct bdrv_iterate_context {
     int err;      int err;
 };  };
   
   static void iostatus_bdrv_it(void *opaque, BlockDriverState *bs)
   {
       bdrv_iostatus_reset(bs);
   }
   
 /**  /**
  * do_cont(): Resume emulation.   * do_cont(): Resume emulation.
  */   */
Line 1309  static int do_cont(Monitor *mon, const Q Line 1092  static int do_cont(Monitor *mon, const Q
 {  {
     struct bdrv_iterate_context context = { mon, 0 };      struct bdrv_iterate_context context = { mon, 0 };
   
     if (incoming_expected) {      if (runstate_check(RUN_STATE_INMIGRATE)) {
         qerror_report(QERR_MIGRATION_EXPECTED);          qerror_report(QERR_MIGRATION_EXPECTED);
         return -1;          return -1;
       } else if (runstate_check(RUN_STATE_INTERNAL_ERROR) ||
                  runstate_check(RUN_STATE_SHUTDOWN)) {
           qerror_report(QERR_RESET_REQUIRED);
           return -1;
     }      }
   
       bdrv_iterate(iostatus_bdrv_it, NULL);
     bdrv_iterate(encrypted_bdrv_it, &context);      bdrv_iterate(encrypted_bdrv_it, &context);
     /* only resume the vm if all keys are set and valid */      /* only resume the vm if all keys are set and valid */
     if (!context.err) {      if (!context.err) {
Line 2008  static void do_boot_set(Monitor *mon, co Line 1797  static void do_boot_set(Monitor *mon, co
 }  }
   
 /**  /**
  * do_system_reset(): Issue a machine reset  
  */  
 static int do_system_reset(Monitor *mon, const QDict *qdict,  
                            QObject **ret_data)  
 {  
     qemu_system_reset_request();  
     return 0;  
 }  
   
 /**  
  * do_system_powerdown(): Issue a machine powerdown   * do_system_powerdown(): Issue a machine powerdown
  */   */
 static int do_system_powerdown(Monitor *mon, const QDict *qdict,  static int do_system_powerdown(Monitor *mon, const QDict *qdict,
Line 2054  static void print_pte(Monitor *mon, targ Line 1833  static void print_pte(Monitor *mon, targ
   
 static void tlb_info_32(Monitor *mon, CPUState *env)  static void tlb_info_32(Monitor *mon, CPUState *env)
 {  {
     int l1, l2;      unsigned int l1, l2;
     uint32_t pgd, pde, pte;      uint32_t pgd, pde, pte;
   
     pgd = env->cr[3] & ~0xfff;      pgd = env->cr[3] & ~0xfff;
Line 2082  static void tlb_info_32(Monitor *mon, CP Line 1861  static void tlb_info_32(Monitor *mon, CP
   
 static void tlb_info_pae32(Monitor *mon, CPUState *env)  static void tlb_info_pae32(Monitor *mon, CPUState *env)
 {  {
     int l1, l2, l3;      unsigned int l1, l2, l3;
     uint64_t pdpe, pde, pte;      uint64_t pdpe, pde, pte;
     uint64_t pdp_addr, pd_addr, pt_addr;      uint64_t pdp_addr, pd_addr, pt_addr;
   
Line 2226  static void mem_print(Monitor *mon, targ Line 2005  static void mem_print(Monitor *mon, targ
   
 static void mem_info_32(Monitor *mon, CPUState *env)  static void mem_info_32(Monitor *mon, CPUState *env)
 {  {
     int l1, l2, prot, last_prot;      unsigned int l1, l2;
       int prot, last_prot;
     uint32_t pgd, pde, pte;      uint32_t pgd, pde, pte;
     target_phys_addr_t start, end;      target_phys_addr_t start, end;
   
Line 2247  static void mem_info_32(Monitor *mon, CP Line 2027  static void mem_info_32(Monitor *mon, CP
                     pte = le32_to_cpu(pte);                      pte = le32_to_cpu(pte);
                     end = (l1 << 22) + (l2 << 12);                      end = (l1 << 22) + (l2 << 12);
                     if (pte & PG_PRESENT_MASK) {                      if (pte & PG_PRESENT_MASK) {
                         prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);                          prot = pte & pde &
                               (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
                     } else {                      } else {
                         prot = 0;                          prot = 0;
                     }                      }
Line 2259  static void mem_info_32(Monitor *mon, CP Line 2040  static void mem_info_32(Monitor *mon, CP
             mem_print(mon, &start, &last_prot, end, prot);              mem_print(mon, &start, &last_prot, end, prot);
         }          }
     }      }
       /* Flush last range */
       mem_print(mon, &start, &last_prot, (target_phys_addr_t)1 << 32, 0);
 }  }
   
 static void mem_info_pae32(Monitor *mon, CPUState *env)  static void mem_info_pae32(Monitor *mon, CPUState *env)
 {  {
     int l1, l2, l3, prot, last_prot;      unsigned int l1, l2, l3;
       int prot, last_prot;
     uint64_t pdpe, pde, pte;      uint64_t pdpe, pde, pte;
     uint64_t pdp_addr, pd_addr, pt_addr;      uint64_t pdp_addr, pd_addr, pt_addr;
     target_phys_addr_t start, end;      target_phys_addr_t start, end;
Line 2293  static void mem_info_pae32(Monitor *mon, Line 2077  static void mem_info_pae32(Monitor *mon,
                             pte = le64_to_cpu(pte);                              pte = le64_to_cpu(pte);
                             end = (l1 << 30) + (l2 << 21) + (l3 << 12);                              end = (l1 << 30) + (l2 << 21) + (l3 << 12);
                             if (pte & PG_PRESENT_MASK) {                              if (pte & PG_PRESENT_MASK) {
                                 prot = pte & (PG_USER_MASK | PG_RW_MASK |                                  prot = pte & pde & (PG_USER_MASK | PG_RW_MASK |
                                               PG_PRESENT_MASK);                                                      PG_PRESENT_MASK);
                             } else {                              } else {
                                 prot = 0;                                  prot = 0;
                             }                              }
Line 2311  static void mem_info_pae32(Monitor *mon, Line 2095  static void mem_info_pae32(Monitor *mon,
             mem_print(mon, &start, &last_prot, end, prot);              mem_print(mon, &start, &last_prot, end, prot);
         }          }
     }      }
       /* Flush last range */
       mem_print(mon, &start, &last_prot, (target_phys_addr_t)1 << 32, 0);
 }  }
   
   
Line 2339  static void mem_info_64(Monitor *mon, CP Line 2125  static void mem_info_64(Monitor *mon, CP
                     if (pdpe & PG_PSE_MASK) {                      if (pdpe & PG_PSE_MASK) {
                         prot = pdpe & (PG_USER_MASK | PG_RW_MASK |                          prot = pdpe & (PG_USER_MASK | PG_RW_MASK |
                                        PG_PRESENT_MASK);                                         PG_PRESENT_MASK);
                           prot &= pml4e;
                         mem_print(mon, &start, &last_prot, end, prot);                          mem_print(mon, &start, &last_prot, end, prot);
                     } else {                      } else {
                         pd_addr = pdpe & 0x3fffffffff000ULL;                          pd_addr = pdpe & 0x3fffffffff000ULL;
Line 2350  static void mem_info_64(Monitor *mon, CP Line 2137  static void mem_info_64(Monitor *mon, CP
                                 if (pde & PG_PSE_MASK) {                                  if (pde & PG_PSE_MASK) {
                                     prot = pde & (PG_USER_MASK | PG_RW_MASK |                                      prot = pde & (PG_USER_MASK | PG_RW_MASK |
                                                   PG_PRESENT_MASK);                                                    PG_PRESENT_MASK);
                                       prot &= pml4e & pdpe;
                                     mem_print(mon, &start, &last_prot, end, prot);                                      mem_print(mon, &start, &last_prot, end, prot);
                                 } else {                                  } else {
                                     pt_addr = pde & 0x3fffffffff000ULL;                                      pt_addr = pde & 0x3fffffffff000ULL;
Line 2363  static void mem_info_64(Monitor *mon, CP Line 2151  static void mem_info_64(Monitor *mon, CP
                                         if (pte & PG_PRESENT_MASK) {                                          if (pte & PG_PRESENT_MASK) {
                                             prot = pte & (PG_USER_MASK | PG_RW_MASK |                                              prot = pte & (PG_USER_MASK | PG_RW_MASK |
                                                           PG_PRESENT_MASK);                                                            PG_PRESENT_MASK);
                                               prot &= pml4e & pdpe & pde;
                                         } else {                                          } else {
                                             prot = 0;                                              prot = 0;
                                         }                                          }
Line 2385  static void mem_info_64(Monitor *mon, CP Line 2174  static void mem_info_64(Monitor *mon, CP
             mem_print(mon, &start, &last_prot, end, prot);              mem_print(mon, &start, &last_prot, end, prot);
         }          }
     }      }
       /* Flush last range */
       mem_print(mon, &start, &last_prot, (target_phys_addr_t)1 << 48, 0);
 }  }
 #endif  #endif
   
Line 2442  static void tlb_info(Monitor *mon) Line 2233  static void tlb_info(Monitor *mon)
   
 #endif  #endif
   
 #if defined(TARGET_SPARC)  #if defined(TARGET_SPARC) || defined(TARGET_PPC)
 static void tlb_info(Monitor *mon)  static void tlb_info(Monitor *mon)
 {  {
     CPUState *env1 = mon_get_cpu();      CPUState *env1 = mon_get_cpu();
Line 2451  static void tlb_info(Monitor *mon) Line 2242  static void tlb_info(Monitor *mon)
 }  }
 #endif  #endif
   
 static void do_info_kvm_print(Monitor *mon, const QObject *data)  static void do_info_mtree(Monitor *mon)
 {  
     QDict *qdict;  
   
     qdict = qobject_to_qdict(data);  
   
     monitor_printf(mon, "kvm support: ");  
     if (qdict_get_bool(qdict, "present")) {  
         monitor_printf(mon, "%s\n", qdict_get_bool(qdict, "enabled") ?  
                                     "enabled" : "disabled");  
     } else {  
         monitor_printf(mon, "not compiled\n");  
     }  
 }  
   
 static void do_info_kvm(Monitor *mon, QObject **ret_data)  
 {  {
 #ifdef CONFIG_KVM      mtree_info((fprintf_function)monitor_printf, mon);
     *ret_data = qobject_from_jsonf("{ 'enabled': %i, 'present': true }",  
                                    kvm_enabled());  
 #else  
     *ret_data = qobject_from_jsonf("{ 'enabled': false, 'present': false }");  
 #endif  
 }  }
   
 static void do_info_numa(Monitor *mon)  static void do_info_numa(Monitor *mon)
Line 2545  static void do_stop_capture(Monitor *mon Line 2316  static void do_stop_capture(Monitor *mon
         if (i == n) {          if (i == n) {
             s->ops.destroy (s->opaque);              s->ops.destroy (s->opaque);
             QLIST_REMOVE (s, entries);              QLIST_REMOVE (s, entries);
             qemu_free (s);              g_free (s);
             return;              return;
         }          }
     }      }
Line 2562  static void do_wav_capture(Monitor *mon, Line 2333  static void do_wav_capture(Monitor *mon,
     int nchannels = qdict_get_try_int(qdict, "nchannels", -1);      int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
     CaptureState *s;      CaptureState *s;
   
     s = qemu_mallocz (sizeof (*s));      s = g_malloc0 (sizeof (*s));
   
     freq = has_freq ? freq : 44100;      freq = has_freq ? freq : 44100;
     bits = has_bits ? bits : 16;      bits = has_bits ? bits : 16;
Line 2570  static void do_wav_capture(Monitor *mon, Line 2341  static void do_wav_capture(Monitor *mon,
   
     if (wav_start_capture (s, path, freq, bits, nchannels)) {      if (wav_start_capture (s, path, freq, bits, nchannels)) {
         monitor_printf(mon, "Failed to add wave capture\n");          monitor_printf(mon, "Failed to add wave capture\n");
         qemu_free (s);          g_free (s);
         return;          return;
     }      }
     QLIST_INSERT_HEAD (&capture_head, s, entries);      QLIST_INSERT_HEAD (&capture_head, s, entries);
Line 2596  static int do_inject_nmi(Monitor *mon, c Line 2367  static int do_inject_nmi(Monitor *mon, c
 }  }
 #endif  #endif
   
 static void do_info_status_print(Monitor *mon, const QObject *data)  
 {  
     QDict *qdict;  
   
     qdict = qobject_to_qdict(data);  
   
     monitor_printf(mon, "VM status: ");  
     if (qdict_get_bool(qdict, "running")) {  
         monitor_printf(mon, "running");  
         if (qdict_get_bool(qdict, "singlestep")) {  
             monitor_printf(mon, " (single step mode)");  
         }  
     } else {  
         monitor_printf(mon, "paused");  
     }  
   
     monitor_printf(mon, "\n");  
 }  
   
 static void do_info_status(Monitor *mon, QObject **ret_data)  
 {  
     *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i }",  
                                     vm_running, singlestep);  
 }  
   
 static qemu_acl *find_acl(Monitor *mon, const char *name)  static qemu_acl *find_acl(Monitor *mon, const char *name)
 {  {
     qemu_acl *acl = qemu_acl_find(name);      qemu_acl *acl = qemu_acl_find(name);
Line 2758  static int do_getfd(Monitor *mon, const  Line 2504  static int do_getfd(Monitor *mon, const 
     mon_fd_t *monfd;      mon_fd_t *monfd;
     int fd;      int fd;
   
     fd = qemu_chr_get_msgfd(mon->chr);      fd = qemu_chr_fe_get_msgfd(mon->chr);
     if (fd == -1) {      if (fd == -1) {
         qerror_report(QERR_FD_NOT_SUPPLIED);          qerror_report(QERR_FD_NOT_SUPPLIED);
         return -1;          return -1;
Line 2780  static int do_getfd(Monitor *mon, const  Line 2526  static int do_getfd(Monitor *mon, const 
         return 0;          return 0;
     }      }
   
     monfd = qemu_mallocz(sizeof(mon_fd_t));      monfd = g_malloc0(sizeof(mon_fd_t));
     monfd->name = qemu_strdup(fdname);      monfd->name = g_strdup(fdname);
     monfd->fd = fd;      monfd->fd = fd;
   
     QLIST_INSERT_HEAD(&mon->fds, monfd, next);      QLIST_INSERT_HEAD(&mon->fds, monfd, next);
Line 2800  static int do_closefd(Monitor *mon, cons Line 2546  static int do_closefd(Monitor *mon, cons
   
         QLIST_REMOVE(monfd, next);          QLIST_REMOVE(monfd, next);
         close(monfd->fd);          close(monfd->fd);
         qemu_free(monfd->name);          g_free(monfd->name);
         qemu_free(monfd);          g_free(monfd);
         return 0;          return 0;
     }      }
   
Line 2811  static int do_closefd(Monitor *mon, cons Line 2557  static int do_closefd(Monitor *mon, cons
   
 static void do_loadvm(Monitor *mon, const QDict *qdict)  static void do_loadvm(Monitor *mon, const QDict *qdict)
 {  {
     int saved_vm_running  = vm_running;      int saved_vm_running  = runstate_is_running();
     const char *name = qdict_get_str(qdict, "name");      const char *name = qdict_get_str(qdict, "name");
   
     vm_stop(VMSTOP_LOADVM);      vm_stop(RUN_STATE_RESTORE_VM);
   
     if (load_vmstate(name) == 0 && saved_vm_running) {      if (load_vmstate(name) == 0 && saved_vm_running) {
         vm_start();          vm_start();
Line 2836  int monitor_get_fd(Monitor *mon, const c Line 2582  int monitor_get_fd(Monitor *mon, const c
   
         /* caller takes ownership of fd */          /* caller takes ownership of fd */
         QLIST_REMOVE(monfd, next);          QLIST_REMOVE(monfd, next);
         qemu_free(monfd->name);          g_free(monfd->name);
         qemu_free(monfd);          g_free(monfd);
   
         return fd;          return fd;
     }      }
Line 2845  int monitor_get_fd(Monitor *mon, const c Line 2591  int monitor_get_fd(Monitor *mon, const c
     return -1;      return -1;
 }  }
   
 static const mon_cmd_t mon_cmds[] = {  /* mon_cmds and info_cmds would be sorted at runtime */
   static mon_cmd_t mon_cmds[] = {
 #include "hmp-commands.h"  #include "hmp-commands.h"
     { NULL, NULL, },      { NULL, NULL, },
 };  };
   
 /* Please update hmp-commands.hx when adding or changing commands */  /* Please update hmp-commands.hx when adding or changing commands */
 static const mon_cmd_t info_cmds[] = {  static mon_cmd_t info_cmds[] = {
     {      {
         .name       = "version",          .name       = "version",
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show the version of QEMU",          .help       = "show the version of QEMU",
         .user_print = do_info_version_print,          .mhandler.info = hmp_info_version,
         .mhandler.info_new = do_info_version,  
     },      },
     {      {
         .name       = "network",          .name       = "network",
Line 2872  static const mon_cmd_t info_cmds[] = { Line 2618  static const mon_cmd_t info_cmds[] = {
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show the character devices",          .help       = "show the character devices",
         .user_print = qemu_chr_info_print,          .mhandler.info = hmp_info_chardev,
         .mhandler.info_new = qemu_chr_info,  
     },      },
     {      {
         .name       = "block",          .name       = "block",
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show the block devices",          .help       = "show the block devices",
         .user_print = bdrv_info_print,          .mhandler.info = hmp_info_block,
         .mhandler.info_new = bdrv_info,  
     },      },
     {      {
         .name       = "blockstats",          .name       = "blockstats",
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show block device statistics",          .help       = "show block device statistics",
         .user_print = bdrv_stats_print,          .mhandler.info = hmp_info_blockstats,
         .mhandler.info_new = bdrv_info_stats,  
     },      },
     {      {
         .name       = "registers",          .name       = "registers",
Line 2903  static const mon_cmd_t info_cmds[] = { Line 2646  static const mon_cmd_t info_cmds[] = {
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show infos for each CPU",          .help       = "show infos for each CPU",
         .user_print = monitor_print_cpus,          .mhandler.info = hmp_info_cpus,
         .mhandler.info_new = do_info_cpus,  
     },      },
     {      {
         .name       = "history",          .name       = "history",
Line 2913  static const mon_cmd_t info_cmds[] = { Line 2655  static const mon_cmd_t info_cmds[] = {
         .help       = "show the command line history",          .help       = "show the command line history",
         .mhandler.info = do_info_history,          .mhandler.info = do_info_history,
     },      },
   #if defined(TARGET_I386) || defined(TARGET_PPC) || defined(TARGET_MIPS) || \
       defined(TARGET_LM32) || (defined(TARGET_SPARC) && !defined(TARGET_SPARC64))
     {      {
         .name       = "irq",          .name       = "irq",
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show the interrupts statistics (if available)",          .help       = "show the interrupts statistics (if available)",
   #ifdef TARGET_SPARC
           .mhandler.info = sun4m_irq_info,
   #elif defined(TARGET_LM32)
           .mhandler.info = lm32_irq_info,
   #else
         .mhandler.info = irq_info,          .mhandler.info = irq_info,
   #endif
     },      },
     {      {
         .name       = "pic",          .name       = "pic",
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show i8259 (PIC) state",          .help       = "show i8259 (PIC) state",
   #ifdef TARGET_SPARC
           .mhandler.info = sun4m_pic_info,
   #elif defined(TARGET_LM32)
           .mhandler.info = lm32_do_pic_info,
   #else
         .mhandler.info = pic_info,          .mhandler.info = pic_info,
   #endif
     },      },
   #endif
     {      {
         .name       = "pci",          .name       = "pci",
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show PCI info",          .help       = "show PCI info",
         .user_print = do_pci_info_print,          .mhandler.info = hmp_info_pci,
         .mhandler.info_new = do_pci_info,  
     },      },
 #if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC)  #if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC) || \
       defined(TARGET_PPC)
     {      {
         .name       = "tlb",          .name       = "tlb",
         .args_type  = "",          .args_type  = "",
Line 2954  static const mon_cmd_t info_cmds[] = { Line 2711  static const mon_cmd_t info_cmds[] = {
     },      },
 #endif  #endif
     {      {
           .name       = "mtree",
           .args_type  = "",
           .params     = "",
           .help       = "show memory tree",
           .mhandler.info = do_info_mtree,
       },
       {
         .name       = "jit",          .name       = "jit",
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
Line 2965  static const mon_cmd_t info_cmds[] = { Line 2729  static const mon_cmd_t info_cmds[] = {
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show KVM information",          .help       = "show KVM information",
         .user_print = do_info_kvm_print,          .mhandler.info = hmp_info_kvm,
         .mhandler.info_new = do_info_kvm,  
     },      },
     {      {
         .name       = "numa",          .name       = "numa",
Line 3015  static const mon_cmd_t info_cmds[] = { Line 2778  static const mon_cmd_t info_cmds[] = {
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show the current VM status (running|paused)",          .help       = "show the current VM status (running|paused)",
         .user_print = do_info_status_print,          .mhandler.info = hmp_info_status,
         .mhandler.info_new = do_info_status,  
     },      },
     {      {
         .name       = "pcmcia",          .name       = "pcmcia",
Line 3030  static const mon_cmd_t info_cmds[] = { Line 2792  static const mon_cmd_t info_cmds[] = {
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show which guest mouse is receiving events",          .help       = "show which guest mouse is receiving events",
         .user_print = do_info_mice_print,          .mhandler.info = hmp_info_mice,
         .mhandler.info_new = do_info_mice,  
     },      },
     {      {
         .name       = "vnc",          .name       = "vnc",
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show the vnc server status",          .help       = "show the vnc server status",
         .user_print = do_info_vnc_print,          .mhandler.info = hmp_info_vnc,
         .mhandler.info_new = do_info_vnc,  
     },      },
 #if defined(CONFIG_SPICE)  #if defined(CONFIG_SPICE)
     {      {
Line 3047  static const mon_cmd_t info_cmds[] = { Line 2807  static const mon_cmd_t info_cmds[] = {
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show the spice server status",          .help       = "show the spice server status",
         .user_print = do_info_spice_print,          .mhandler.info = hmp_info_spice,
         .mhandler.info_new = do_info_spice,  
     },      },
 #endif  #endif
     {      {
Line 3056  static const mon_cmd_t info_cmds[] = { Line 2815  static const mon_cmd_t info_cmds[] = {
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show the current VM name",          .help       = "show the current VM name",
         .user_print = do_info_name_print,          .mhandler.info = hmp_info_name,
         .mhandler.info_new = do_info_name,  
     },      },
     {      {
         .name       = "uuid",          .name       = "uuid",
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show the current VM UUID",          .help       = "show the current VM UUID",
         .user_print = do_info_uuid_print,          .mhandler.info = hmp_info_uuid,
         .mhandler.info_new = do_info_uuid,  
     },      },
 #if defined(TARGET_PPC)  #if defined(TARGET_PPC)
     {      {
Line 3090  static const mon_cmd_t info_cmds[] = { Line 2847  static const mon_cmd_t info_cmds[] = {
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show migration status",          .help       = "show migration status",
         .user_print = do_info_migrate_print,          .mhandler.info = hmp_info_migrate,
         .mhandler.info_new = do_info_migrate,  
     },      },
     {      {
         .name       = "balloon",          .name       = "balloon",
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show balloon information",          .help       = "show balloon information",
         .user_print = monitor_print_balloon,          .mhandler.info = hmp_info_balloon,
         .mhandler.info_async = do_info_balloon,  
         .flags      = MONITOR_CMD_ASYNC,  
     },      },
     {      {
         .name       = "qtree",          .name       = "qtree",
Line 3123  static const mon_cmd_t info_cmds[] = { Line 2877  static const mon_cmd_t info_cmds[] = {
         .help       = "show roms",          .help       = "show roms",
         .mhandler.info = do_info_roms,          .mhandler.info = do_info_roms,
     },      },
 #if defined(CONFIG_SIMPLE_TRACE)  #if defined(CONFIG_TRACE_SIMPLE)
     {      {
         .name       = "trace",          .name       = "trace",
         .args_type  = "",          .args_type  = "",
Line 3131  static const mon_cmd_t info_cmds[] = { Line 2885  static const mon_cmd_t info_cmds[] = {
         .help       = "show current contents of trace buffer",          .help       = "show current contents of trace buffer",
         .mhandler.info = do_info_trace,          .mhandler.info = do_info_trace,
     },      },
   #endif
     {      {
         .name       = "trace-events",          .name       = "trace-events",
         .args_type  = "",          .args_type  = "",
         .params     = "",          .params     = "",
         .help       = "show available trace-events & their state",          .help       = "show available trace-events & their state",
         .mhandler.info = do_info_trace_events,          .mhandler.info = do_trace_print_events,
     },      },
 #endif  
     {      {
         .name       = NULL,          .name       = NULL,
     },      },
 };  };
   
 static const mon_cmd_t qmp_cmds[] = {  static const mon_cmd_t qmp_cmds[] = {
 #include "qmp-commands.h"  #include "qmp-commands-old.h"
     { /* NULL */ },  
 };  
   
 static const mon_cmd_t qmp_query_cmds[] = {  
     {  
         .name       = "version",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show the version of QEMU",  
         .user_print = do_info_version_print,  
         .mhandler.info_new = do_info_version,  
     },  
     {  
         .name       = "commands",  
         .args_type  = "",  
         .params     = "",  
         .help       = "list QMP available commands",  
         .user_print = monitor_user_noop,  
         .mhandler.info_new = do_info_commands,  
     },  
     {  
         .name       = "chardev",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show the character devices",  
         .user_print = qemu_chr_info_print,  
         .mhandler.info_new = qemu_chr_info,  
     },  
     {  
         .name       = "block",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show the block devices",  
         .user_print = bdrv_info_print,  
         .mhandler.info_new = bdrv_info,  
     },  
     {  
         .name       = "blockstats",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show block device statistics",  
         .user_print = bdrv_stats_print,  
         .mhandler.info_new = bdrv_info_stats,  
     },  
     {  
         .name       = "cpus",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show infos for each CPU",  
         .user_print = monitor_print_cpus,  
         .mhandler.info_new = do_info_cpus,  
     },  
     {  
         .name       = "pci",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show PCI info",  
         .user_print = do_pci_info_print,  
         .mhandler.info_new = do_pci_info,  
     },  
     {  
         .name       = "kvm",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show KVM information",  
         .user_print = do_info_kvm_print,  
         .mhandler.info_new = do_info_kvm,  
     },  
     {  
         .name       = "status",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show the current VM status (running|paused)",  
         .user_print = do_info_status_print,  
         .mhandler.info_new = do_info_status,  
     },  
     {  
         .name       = "mice",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show which guest mouse is receiving events",  
         .user_print = do_info_mice_print,  
         .mhandler.info_new = do_info_mice,  
     },  
     {  
         .name       = "vnc",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show the vnc server status",  
         .user_print = do_info_vnc_print,  
         .mhandler.info_new = do_info_vnc,  
     },  
 #if defined(CONFIG_SPICE)  
     {  
         .name       = "spice",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show the spice server status",  
         .user_print = do_info_spice_print,  
         .mhandler.info_new = do_info_spice,  
     },  
 #endif  
     {  
         .name       = "name",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show the current VM name",  
         .user_print = do_info_name_print,  
         .mhandler.info_new = do_info_name,  
     },  
     {  
         .name       = "uuid",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show the current VM UUID",  
         .user_print = do_info_uuid_print,  
         .mhandler.info_new = do_info_uuid,  
     },  
     {  
         .name       = "migrate",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show migration status",  
         .user_print = do_info_migrate_print,  
         .mhandler.info_new = do_info_migrate,  
     },  
     {  
         .name       = "balloon",  
         .args_type  = "",  
         .params     = "",  
         .help       = "show balloon information",  
         .user_print = monitor_print_balloon,  
         .mhandler.info_async = do_info_balloon,  
         .flags      = MONITOR_CMD_ASYNC,  
     },  
     { /* NULL */ },      { /* NULL */ },
 };  };
   
Line 3617  static const MonitorDef monitor_defs[] = Line 3236  static const MonitorDef monitor_defs[] =
 #endif  #endif
     { "tbr", offsetof(CPUState, tbr) },      { "tbr", offsetof(CPUState, tbr) },
     { "fsr", offsetof(CPUState, fsr) },      { "fsr", offsetof(CPUState, fsr) },
     { "f0", offsetof(CPUState, fpr[0]) },      { "f0", offsetof(CPUState, fpr[0].l.upper) },
     { "f1", offsetof(CPUState, fpr[1]) },      { "f1", offsetof(CPUState, fpr[0].l.lower) },
     { "f2", offsetof(CPUState, fpr[2]) },      { "f2", offsetof(CPUState, fpr[1].l.upper) },
     { "f3", offsetof(CPUState, fpr[3]) },      { "f3", offsetof(CPUState, fpr[1].l.lower) },
     { "f4", offsetof(CPUState, fpr[4]) },      { "f4", offsetof(CPUState, fpr[2].l.upper) },
     { "f5", offsetof(CPUState, fpr[5]) },      { "f5", offsetof(CPUState, fpr[2].l.lower) },
     { "f6", offsetof(CPUState, fpr[6]) },      { "f6", offsetof(CPUState, fpr[3].l.upper) },
     { "f7", offsetof(CPUState, fpr[7]) },      { "f7", offsetof(CPUState, fpr[3].l.lower) },
     { "f8", offsetof(CPUState, fpr[8]) },      { "f8", offsetof(CPUState, fpr[4].l.upper) },
     { "f9", offsetof(CPUState, fpr[9]) },      { "f9", offsetof(CPUState, fpr[4].l.lower) },
     { "f10", offsetof(CPUState, fpr[10]) },      { "f10", offsetof(CPUState, fpr[5].l.upper) },
     { "f11", offsetof(CPUState, fpr[11]) },      { "f11", offsetof(CPUState, fpr[5].l.lower) },
     { "f12", offsetof(CPUState, fpr[12]) },      { "f12", offsetof(CPUState, fpr[6].l.upper) },
     { "f13", offsetof(CPUState, fpr[13]) },      { "f13", offsetof(CPUState, fpr[6].l.lower) },
     { "f14", offsetof(CPUState, fpr[14]) },      { "f14", offsetof(CPUState, fpr[7].l.upper) },
     { "f15", offsetof(CPUState, fpr[15]) },      { "f15", offsetof(CPUState, fpr[7].l.lower) },
     { "f16", offsetof(CPUState, fpr[16]) },      { "f16", offsetof(CPUState, fpr[8].l.upper) },
     { "f17", offsetof(CPUState, fpr[17]) },      { "f17", offsetof(CPUState, fpr[8].l.lower) },
     { "f18", offsetof(CPUState, fpr[18]) },      { "f18", offsetof(CPUState, fpr[9].l.upper) },
     { "f19", offsetof(CPUState, fpr[19]) },      { "f19", offsetof(CPUState, fpr[9].l.lower) },
     { "f20", offsetof(CPUState, fpr[20]) },      { "f20", offsetof(CPUState, fpr[10].l.upper) },
     { "f21", offsetof(CPUState, fpr[21]) },      { "f21", offsetof(CPUState, fpr[10].l.lower) },
     { "f22", offsetof(CPUState, fpr[22]) },      { "f22", offsetof(CPUState, fpr[11].l.upper) },
     { "f23", offsetof(CPUState, fpr[23]) },      { "f23", offsetof(CPUState, fpr[11].l.lower) },
     { "f24", offsetof(CPUState, fpr[24]) },      { "f24", offsetof(CPUState, fpr[12].l.upper) },
     { "f25", offsetof(CPUState, fpr[25]) },      { "f25", offsetof(CPUState, fpr[12].l.lower) },
     { "f26", offsetof(CPUState, fpr[26]) },      { "f26", offsetof(CPUState, fpr[13].l.upper) },
     { "f27", offsetof(CPUState, fpr[27]) },      { "f27", offsetof(CPUState, fpr[13].l.lower) },
     { "f28", offsetof(CPUState, fpr[28]) },      { "f28", offsetof(CPUState, fpr[14].l.upper) },
     { "f29", offsetof(CPUState, fpr[29]) },      { "f29", offsetof(CPUState, fpr[14].l.lower) },
     { "f30", offsetof(CPUState, fpr[30]) },      { "f30", offsetof(CPUState, fpr[15].l.upper) },
     { "f31", offsetof(CPUState, fpr[31]) },      { "f31", offsetof(CPUState, fpr[15].l.lower) },
 #ifdef TARGET_SPARC64  #ifdef TARGET_SPARC64
     { "f32", offsetof(CPUState, fpr[32]) },      { "f32", offsetof(CPUState, fpr[16]) },
     { "f34", offsetof(CPUState, fpr[34]) },      { "f34", offsetof(CPUState, fpr[17]) },
     { "f36", offsetof(CPUState, fpr[36]) },      { "f36", offsetof(CPUState, fpr[18]) },
     { "f38", offsetof(CPUState, fpr[38]) },      { "f38", offsetof(CPUState, fpr[19]) },
     { "f40", offsetof(CPUState, fpr[40]) },      { "f40", offsetof(CPUState, fpr[20]) },
     { "f42", offsetof(CPUState, fpr[42]) },      { "f42", offsetof(CPUState, fpr[21]) },
     { "f44", offsetof(CPUState, fpr[44]) },      { "f44", offsetof(CPUState, fpr[22]) },
     { "f46", offsetof(CPUState, fpr[46]) },      { "f46", offsetof(CPUState, fpr[23]) },
     { "f48", offsetof(CPUState, fpr[48]) },      { "f48", offsetof(CPUState, fpr[24]) },
     { "f50", offsetof(CPUState, fpr[50]) },      { "f50", offsetof(CPUState, fpr[25]) },
     { "f52", offsetof(CPUState, fpr[52]) },      { "f52", offsetof(CPUState, fpr[26]) },
     { "f54", offsetof(CPUState, fpr[54]) },      { "f54", offsetof(CPUState, fpr[27]) },
     { "f56", offsetof(CPUState, fpr[56]) },      { "f56", offsetof(CPUState, fpr[28]) },
     { "f58", offsetof(CPUState, fpr[58]) },      { "f58", offsetof(CPUState, fpr[29]) },
     { "f60", offsetof(CPUState, fpr[60]) },      { "f60", offsetof(CPUState, fpr[30]) },
     { "f62", offsetof(CPUState, fpr[62]) },      { "f62", offsetof(CPUState, fpr[31]) },
     { "asi", offsetof(CPUState, asi) },      { "asi", offsetof(CPUState, asi) },
     { "pstate", offsetof(CPUState, pstate) },      { "pstate", offsetof(CPUState, pstate) },
     { "cansave", offsetof(CPUState, cansave) },      { "cansave", offsetof(CPUState, cansave) },
Line 4034  static char *key_get_info(const char *ty Line 3653  static char *key_get_info(const char *ty
     }      }
     len = p - type;      len = p - type;
   
     str = qemu_malloc(len + 1);      str = g_malloc(len + 1);
     memcpy(str, type, len);      memcpy(str, type, len);
     str[len] = '\0';      str[len] = '\0';
   
Line 4078  static const mon_cmd_t *monitor_find_com Line 3697  static const mon_cmd_t *monitor_find_com
     return search_dispatch_table(mon_cmds, cmdname);      return search_dispatch_table(mon_cmds, cmdname);
 }  }
   
 static const mon_cmd_t *qmp_find_query_cmd(const char *info_item)  
 {  
     return search_dispatch_table(qmp_query_cmds, info_item);  
 }  
   
 static const mon_cmd_t *qmp_find_cmd(const char *cmdname)  static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
 {  {
     return search_dispatch_table(qmp_cmds, cmdname);      return search_dispatch_table(qmp_cmds, cmdname);
Line 4417  static const mon_cmd_t *monitor_parse_co Line 4031  static const mon_cmd_t *monitor_parse_co
             monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);              monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
             goto fail;              goto fail;
         }          }
         qemu_free(key);          g_free(key);
         key = NULL;          key = NULL;
     }      }
     /* check that all arguments were parsed */      /* check that all arguments were parsed */
Line 4432  static const mon_cmd_t *monitor_parse_co Line 4046  static const mon_cmd_t *monitor_parse_co
     return cmd;      return cmd;
   
 fail:  fail:
     qemu_free(key);      g_free(key);
     return NULL;      return NULL;
 }  }
   
Line 4593  static void file_completion(const char * Line 4207  static void file_completion(const char *
             /* stat the file to find out if it's a directory.              /* stat the file to find out if it's a directory.
              * In that case add a slash to speed up typing long paths               * In that case add a slash to speed up typing long paths
              */               */
             stat(file, &sb);              if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
             if(S_ISDIR(sb.st_mode))  
                 pstrcat(file, sizeof(file), "/");                  pstrcat(file, sizeof(file), "/");
               }
             readline_add_completion(cur_mon->rs, file);              readline_add_completion(cur_mon->rs, file);
         }          }
     }      }
Line 4631  static void parse_cmdline(const char *cm Line 4245  static void parse_cmdline(const char *cm
         if (nb_args >= MAX_ARGS)          if (nb_args >= MAX_ARGS)
             break;              break;
         ret = get_str(buf, sizeof(buf), &p);          ret = get_str(buf, sizeof(buf), &p);
         args[nb_args] = qemu_strdup(buf);          args[nb_args] = g_strdup(buf);
         nb_args++;          nb_args++;
         if (ret < 0)          if (ret < 0)
             break;              break;
Line 4668  static void monitor_find_completion(cons Line 4282  static void monitor_find_completion(cons
         if (nb_args >= MAX_ARGS) {          if (nb_args >= MAX_ARGS) {
             goto cleanup;              goto cleanup;
         }          }
         args[nb_args++] = qemu_strdup("");          args[nb_args++] = g_strdup("");
     }      }
     if (nb_args <= 1) {      if (nb_args <= 1) {
         /* command completion */          /* command completion */
Line 4743  static void monitor_find_completion(cons Line 4357  static void monitor_find_completion(cons
   
 cleanup:  cleanup:
     for (i = 0; i < nb_args; i++) {      for (i = 0; i < nb_args; i++) {
         qemu_free(args[i]);          g_free(args[i]);
     }      }
 }  }
   
Line 5006  static QDict *qmp_check_input_obj(QObjec Line 4620  static QDict *qmp_check_input_obj(QObjec
     return input_dict;      return input_dict;
 }  }
   
 static void qmp_call_query_cmd(Monitor *mon, const mon_cmd_t *cmd)  
 {  
     QObject *ret_data = NULL;  
   
     if (handler_is_async(cmd)) {  
         qmp_async_info_handler(mon, cmd);  
         if (monitor_has_error(mon)) {  
             monitor_protocol_emitter(mon, NULL);  
         }  
     } else {  
         cmd->mhandler.info_new(mon, &ret_data);  
         monitor_protocol_emitter(mon, ret_data);  
         qobject_decref(ret_data);  
     }  
 }  
   
 static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,  static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
                          const QDict *params)                           const QDict *params)
 {  {
Line 5042  static void handle_qmp_command(JSONMessa Line 4640  static void handle_qmp_command(JSONMessa
     QObject *obj;      QObject *obj;
     QDict *input, *args;      QDict *input, *args;
     const mon_cmd_t *cmd;      const mon_cmd_t *cmd;
       const char *cmd_name;
     Monitor *mon = cur_mon;      Monitor *mon = cur_mon;
     const char *cmd_name, *query_cmd;  
   
     query_cmd = NULL;  
     args = input = NULL;      args = input = NULL;
   
     obj = json_parser_parse(tokens, NULL);      obj = json_parser_parse(tokens, NULL);
Line 5065  static void handle_qmp_command(JSONMessa Line 4662  static void handle_qmp_command(JSONMessa
     qobject_incref(mon->mc->id);      qobject_incref(mon->mc->id);
   
     cmd_name = qdict_get_str(input, "execute");      cmd_name = qdict_get_str(input, "execute");
       trace_handle_qmp_command(mon, cmd_name);
     if (invalid_qmp_mode(mon, cmd_name)) {      if (invalid_qmp_mode(mon, cmd_name)) {
         qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);          qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
         goto err_out;          goto err_out;
     }      }
   
     if (strstart(cmd_name, "query-", &query_cmd)) {      cmd = qmp_find_cmd(cmd_name);
         cmd = qmp_find_query_cmd(query_cmd);  
     } else {  
         cmd = qmp_find_cmd(cmd_name);  
     }  
   
     if (!cmd) {      if (!cmd) {
         qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);          qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
         goto err_out;          goto err_out;
Line 5094  static void handle_qmp_command(JSONMessa Line 4687  static void handle_qmp_command(JSONMessa
         goto err_out;          goto err_out;
     }      }
   
     if (query_cmd) {      if (handler_is_async(cmd)) {
         qmp_call_query_cmd(mon, cmd);  
     } else if (handler_is_async(cmd)) {  
         err = qmp_async_cmd_handler(mon, cmd, args);          err = qmp_async_cmd_handler(mon, cmd, args);
         if (err) {          if (err) {
             /* emit the error response */              /* emit the error response */
Line 5174  void monitor_resume(Monitor *mon) Line 4765  void monitor_resume(Monitor *mon)
   
 static QObject *get_qmp_greeting(void)  static QObject *get_qmp_greeting(void)
 {  {
     QObject *ver;      QObject *ver = NULL;
   
     do_info_version(NULL, &ver);      qmp_marshal_input_query_version(NULL, NULL, &ver);
     return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);      return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
 }  }
   
Line 5242  static void monitor_event(void *opaque,  Line 4833  static void monitor_event(void *opaque, 
     }      }
 }  }
   
   static int
   compare_mon_cmd(const void *a, const void *b)
   {
       return strcmp(((const mon_cmd_t *)a)->name,
               ((const mon_cmd_t *)b)->name);
   }
   
   static void sortcmdlist(void)
   {
       int array_num;
       int elem_size = sizeof(mon_cmd_t);
   
       array_num = sizeof(mon_cmds)/elem_size-1;
       qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
   
       array_num = sizeof(info_cmds)/elem_size-1;
       qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
   }
   
   
 /*  /*
  * Local variables:   * Local variables:
Line 5261  void monitor_init(CharDriverState *chr,  Line 4871  void monitor_init(CharDriverState *chr, 
         is_first_init = 0;          is_first_init = 0;
     }      }
   
     mon = qemu_mallocz(sizeof(*mon));      mon = g_malloc0(sizeof(*mon));
   
     mon->chr = chr;      mon->chr = chr;
     mon->flags = flags;      mon->flags = flags;
Line 5271  void monitor_init(CharDriverState *chr,  Line 4881  void monitor_init(CharDriverState *chr, 
     }      }
   
     if (monitor_ctrl_mode(mon)) {      if (monitor_ctrl_mode(mon)) {
         mon->mc = qemu_mallocz(sizeof(MonitorControl));          mon->mc = g_malloc0(sizeof(MonitorControl));
         /* Control mode requires special handlers */          /* Control mode requires special handlers */
         qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,          qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
                               monitor_control_event, mon);                                monitor_control_event, mon);
         qemu_chr_set_echo(chr, true);          qemu_chr_fe_set_echo(chr, true);
     } else {      } else {
         qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,          qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
                               monitor_event, mon);                                monitor_event, mon);
Line 5284  void monitor_init(CharDriverState *chr,  Line 4894  void monitor_init(CharDriverState *chr, 
     QLIST_INSERT_HEAD(&mon_list, mon, entry);      QLIST_INSERT_HEAD(&mon_list, mon, entry);
     if (!default_mon || (flags & MONITOR_IS_DEFAULT))      if (!default_mon || (flags & MONITOR_IS_DEFAULT))
         default_mon = mon;          default_mon = mon;
   
       sortcmdlist();
 }  }
   
 static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)  static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)

Removed from v.1.1.1.15  
changed lines
  Added in v.1.1.1.16


unix.superglobalmegacorp.com