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

version 1.1.1.14, 2018/04/24 18:34:05 version 1.1.1.15, 2018/04/24 18:56:21
Line 56 Line 56
 #include "json-streamer.h"  #include "json-streamer.h"
 #include "json-parser.h"  #include "json-parser.h"
 #include "osdep.h"  #include "osdep.h"
 #include "exec-all.h"  #include "cpu.h"
 #ifdef CONFIG_SIMPLE_TRACE  #ifdef CONFIG_SIMPLE_TRACE
 #include "trace.h"  #include "trace.h"
 #endif  #endif
Line 897  static void print_cpu_iter(QObject *obj, Line 897  static void print_cpu_iter(QObject *obj,
         monitor_printf(mon, " (halted)");          monitor_printf(mon, " (halted)");
     }      }
   
       monitor_printf(mon, " thread_id=%" PRId64 " ",
                      qdict_get_int(cpu, "thread_id"));
   
     monitor_printf(mon, "\n");      monitor_printf(mon, "\n");
 }  }
   
Line 941  static void do_info_cpus(Monitor *mon, Q Line 944  static void do_info_cpus(Monitor *mon, Q
 #elif defined(TARGET_MIPS)  #elif defined(TARGET_MIPS)
         qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));          qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));
 #endif  #endif
           qdict_put(cpu, "thread_id", qint_from_int(env->thread_id));
   
         qlist_append(cpu_list, cpu);          qlist_append(cpu_list, cpu);
     }      }
Line 1016  static int do_quit(Monitor *mon, const Q Line 1020  static int do_quit(Monitor *mon, const Q
     return 0;      return 0;
 }  }
   
   #ifdef CONFIG_VNC
 static int change_vnc_password(const char *password)  static int change_vnc_password(const char *password)
 {  {
     if (!password || !password[0]) {      if (!password || !password[0]) {
Line 1062  static int do_change_vnc(Monitor *mon, c Line 1067  static int do_change_vnc(Monitor *mon, c
   
     return 0;      return 0;
 }  }
   #else
   static int do_change_vnc(Monitor *mon, const char *target, const char *arg)
   {
       qerror_report(QERR_FEATURE_DISABLED, "vnc");
       return -ENODEV;
   }
   #endif
   
 /**  /**
  * do_change(): Change a removable medium, or VNC configuration   * do_change(): Change a removable medium, or VNC configuration
Line 1127  static int set_password(Monitor *mon, co Line 1139  static int set_password(Monitor *mon, co
         }          }
         /* Note that setting an empty password will not disable login through          /* Note that setting an empty password will not disable login through
          * this interface. */           * this interface. */
         rc = vnc_display_password(NULL, password);          return vnc_display_password(NULL, password);
         if (rc != 0) {  
             qerror_report(QERR_SET_PASSWD_FAILED);  
             return -1;  
         }  
         return 0;  
     }      }
   
     qerror_report(QERR_INVALID_PARAMETER, "protocol");      qerror_report(QERR_INVALID_PARAMETER, "protocol");
Line 1171  static int expire_password(Monitor *mon, Line 1178  static int expire_password(Monitor *mon,
     }      }
   
     if (strcmp(protocol, "vnc") == 0) {      if (strcmp(protocol, "vnc") == 0) {
         rc = vnc_display_pw_expire(NULL, when);          return vnc_display_pw_expire(NULL, when);
         if (rc != 0) {      }
             qerror_report(QERR_SET_PASSWD_FAILED);  
       qerror_report(QERR_INVALID_PARAMETER, "protocol");
       return -1;
   }
   
   static int add_graphics_client(Monitor *mon, const QDict *qdict, QObject **ret_data)
   {
       const char *protocol  = qdict_get_str(qdict, "protocol");
       const char *fdname = qdict_get_str(qdict, "fdname");
       CharDriverState *s;
   
       if (strcmp(protocol, "spice") == 0) {
           if (!using_spice) {
               /* correct one? spice isn't a device ,,, */
               qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
             return -1;              return -1;
         }          }
         return 0;          qerror_report(QERR_ADD_CLIENT_FAILED);
           return -1;
   #ifdef CONFIG_VNC
       } else if (strcmp(protocol, "vnc") == 0) {
           int fd = monitor_get_fd(mon, fdname);
           int skipauth = qdict_get_try_bool(qdict, "skipauth", 0);
           vnc_display_add_client(NULL, fd, skipauth);
           return 0;
   #endif
       } else if ((s = qemu_chr_find(protocol)) != NULL) {
           int fd = monitor_get_fd(mon, fdname);
           if (qemu_chr_add_client(s, fd) < 0) {
               qerror_report(QERR_ADD_CLIENT_FAILED);
               return -1;
           }
           return 0;
     }      }
   
     qerror_report(QERR_INVALID_PARAMETER, "protocol");      qerror_report(QERR_INVALID_PARAMETER, "protocol");
Line 1255  static void do_singlestep(Monitor *mon,  Line 1291  static void do_singlestep(Monitor *mon, 
  */   */
 static int do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)  static int do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)
 {  {
     vm_stop(EXCP_INTERRUPT);      vm_stop(VMSTOP_USER);
     return 0;      return 0;
 }  }
   
Line 1427  static void memory_dump(Monitor *mon, in Line 1463  static void memory_dump(Monitor *mon, in
         if (l > line_size)          if (l > line_size)
             l = line_size;              l = line_size;
         if (is_physical) {          if (is_physical) {
             cpu_physical_memory_rw(addr, buf, l, 0);              cpu_physical_memory_read(addr, buf, l);
         } else {          } else {
             env = mon_get_cpu();              env = mon_get_cpu();
             if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {              if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
Line 1603  static int do_physical_memory_save(Monit Line 1639  static int do_physical_memory_save(Monit
         l = sizeof(buf);          l = sizeof(buf);
         if (l > size)          if (l > size)
             l = size;              l = size;
         cpu_physical_memory_rw(addr, buf, l, 0);          cpu_physical_memory_read(addr, buf, l);
         if (fwrite(buf, 1, l, f) != l) {          if (fwrite(buf, 1, l, f) != l) {
             monitor_printf(mon, "fwrite() error in do_physical_memory_save\n");              monitor_printf(mon, "fwrite() error in do_physical_memory_save\n");
             goto exit;              goto exit;
Line 1623  exit: Line 1659  exit:
 static void do_sum(Monitor *mon, const QDict *qdict)  static void do_sum(Monitor *mon, const QDict *qdict)
 {  {
     uint32_t addr;      uint32_t addr;
     uint8_t buf[1];  
     uint16_t sum;      uint16_t sum;
     uint32_t start = qdict_get_int(qdict, "start");      uint32_t start = qdict_get_int(qdict, "start");
     uint32_t size = qdict_get_int(qdict, "size");      uint32_t size = qdict_get_int(qdict, "size");
   
     sum = 0;      sum = 0;
     for(addr = start; addr < (start + size); addr++) {      for(addr = start; addr < (start + size); addr++) {
         cpu_physical_memory_rw(addr, buf, 1, 0);          uint8_t val = ldub_phys(addr);
         /* BSD sum algorithm ('sum' Unix command) */          /* BSD sum algorithm ('sum' Unix command) */
         sum = (sum >> 1) | (sum << 15);          sum = (sum >> 1) | (sum << 15);
         sum += buf[0];          sum += val;
     }      }
     monitor_printf(mon, "%05d\n", sum);      monitor_printf(mon, "%05d\n", sum);
 }  }
Line 1873  static void do_sendkey(Monitor *mon, con Line 1908  static void do_sendkey(Monitor *mon, con
         kbd_put_keycode(keycode & 0x7f);          kbd_put_keycode(keycode & 0x7f);
     }      }
     /* delayed key up events */      /* delayed key up events */
     qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +      qemu_mod_timer(key_timer, qemu_get_clock_ns(vm_clock) +
                    muldiv64(get_ticks_per_sec(), hold_time, 1000));                     muldiv64(get_ticks_per_sec(), hold_time, 1000));
 }  }
   
Line 2024  static void tlb_info_32(Monitor *mon, CP Line 2059  static void tlb_info_32(Monitor *mon, CP
   
     pgd = env->cr[3] & ~0xfff;      pgd = env->cr[3] & ~0xfff;
     for(l1 = 0; l1 < 1024; l1++) {      for(l1 = 0; l1 < 1024; l1++) {
         cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);          cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
         pde = le32_to_cpu(pde);          pde = le32_to_cpu(pde);
         if (pde & PG_PRESENT_MASK) {          if (pde & PG_PRESENT_MASK) {
             if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {              if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
Line 2032  static void tlb_info_32(Monitor *mon, CP Line 2067  static void tlb_info_32(Monitor *mon, CP
                 print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1));                  print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1));
             } else {              } else {
                 for(l2 = 0; l2 < 1024; l2++) {                  for(l2 = 0; l2 < 1024; l2++) {
                     cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,                      cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
                                              (uint8_t *)&pte, 4);  
                     pte = le32_to_cpu(pte);                      pte = le32_to_cpu(pte);
                     if (pte & PG_PRESENT_MASK) {                      if (pte & PG_PRESENT_MASK) {
                         print_pte(mon, (l1 << 22) + (l2 << 12),                          print_pte(mon, (l1 << 22) + (l2 << 12),
Line 2054  static void tlb_info_pae32(Monitor *mon, Line 2088  static void tlb_info_pae32(Monitor *mon,
   
     pdp_addr = env->cr[3] & ~0x1f;      pdp_addr = env->cr[3] & ~0x1f;
     for (l1 = 0; l1 < 4; l1++) {      for (l1 = 0; l1 < 4; l1++) {
         cpu_physical_memory_read(pdp_addr + l1 * 8, (uint8_t *)&pdpe, 8);          cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
         pdpe = le64_to_cpu(pdpe);          pdpe = le64_to_cpu(pdpe);
         if (pdpe & PG_PRESENT_MASK) {          if (pdpe & PG_PRESENT_MASK) {
             pd_addr = pdpe & 0x3fffffffff000ULL;              pd_addr = pdpe & 0x3fffffffff000ULL;
             for (l2 = 0; l2 < 512; l2++) {              for (l2 = 0; l2 < 512; l2++) {
                 cpu_physical_memory_read(pd_addr + l2 * 8,                  cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
                                          (uint8_t *)&pde, 8);  
                 pde = le64_to_cpu(pde);                  pde = le64_to_cpu(pde);
                 if (pde & PG_PRESENT_MASK) {                  if (pde & PG_PRESENT_MASK) {
                     if (pde & PG_PSE_MASK) {                      if (pde & PG_PSE_MASK) {
Line 2070  static void tlb_info_pae32(Monitor *mon, Line 2103  static void tlb_info_pae32(Monitor *mon,
                     } else {                      } else {
                         pt_addr = pde & 0x3fffffffff000ULL;                          pt_addr = pde & 0x3fffffffff000ULL;
                         for (l3 = 0; l3 < 512; l3++) {                          for (l3 = 0; l3 < 512; l3++) {
                             cpu_physical_memory_read(pt_addr + l3 * 8,                              cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
                                                      (uint8_t *)&pte, 8);  
                             pte = le64_to_cpu(pte);                              pte = le64_to_cpu(pte);
                             if (pte & PG_PRESENT_MASK) {                              if (pte & PG_PRESENT_MASK) {
                                 print_pte(mon, (l1 << 30 ) + (l2 << 21)                                  print_pte(mon, (l1 << 30 ) + (l2 << 21)
Line 2096  static void tlb_info_64(Monitor *mon, CP Line 2128  static void tlb_info_64(Monitor *mon, CP
   
     pml4_addr = env->cr[3] & 0x3fffffffff000ULL;      pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
     for (l1 = 0; l1 < 512; l1++) {      for (l1 = 0; l1 < 512; l1++) {
         cpu_physical_memory_read(pml4_addr + l1 * 8, (uint8_t *)&pml4e, 8);          cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
         pml4e = le64_to_cpu(pml4e);          pml4e = le64_to_cpu(pml4e);
         if (pml4e & PG_PRESENT_MASK) {          if (pml4e & PG_PRESENT_MASK) {
             pdp_addr = pml4e & 0x3fffffffff000ULL;              pdp_addr = pml4e & 0x3fffffffff000ULL;
             for (l2 = 0; l2 < 512; l2++) {              for (l2 = 0; l2 < 512; l2++) {
                 cpu_physical_memory_read(pdp_addr + l2 * 8, (uint8_t *)&pdpe,                  cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
                                          8);  
                 pdpe = le64_to_cpu(pdpe);                  pdpe = le64_to_cpu(pdpe);
                 if (pdpe & PG_PRESENT_MASK) {                  if (pdpe & PG_PRESENT_MASK) {
                     if (pdpe & PG_PSE_MASK) {                      if (pdpe & PG_PSE_MASK) {
Line 2112  static void tlb_info_64(Monitor *mon, CP Line 2143  static void tlb_info_64(Monitor *mon, CP
                     } else {                      } else {
                         pd_addr = pdpe & 0x3fffffffff000ULL;                          pd_addr = pdpe & 0x3fffffffff000ULL;
                         for (l3 = 0; l3 < 512; l3++) {                          for (l3 = 0; l3 < 512; l3++) {
                             cpu_physical_memory_read(pd_addr + l3 * 8,                              cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
                                                      (uint8_t *)&pde, 8);  
                             pde = le64_to_cpu(pde);                              pde = le64_to_cpu(pde);
                             if (pde & PG_PRESENT_MASK) {                              if (pde & PG_PRESENT_MASK) {
                                 if (pde & PG_PSE_MASK) {                                  if (pde & PG_PSE_MASK) {
Line 2126  static void tlb_info_64(Monitor *mon, CP Line 2156  static void tlb_info_64(Monitor *mon, CP
                                     for (l4 = 0; l4 < 512; l4++) {                                      for (l4 = 0; l4 < 512; l4++) {
                                         cpu_physical_memory_read(pt_addr                                          cpu_physical_memory_read(pt_addr
                                                                  + l4 * 8,                                                                   + l4 * 8,
                                                                  (uint8_t *)&pte,                                                                   &pte, 8);
                                                                  8);  
                                         pte = le64_to_cpu(pte);                                          pte = le64_to_cpu(pte);
                                         if (pte & PG_PRESENT_MASK) {                                          if (pte & PG_PRESENT_MASK) {
                                             print_pte(mon, (l1 << 39) +                                              print_pte(mon, (l1 << 39) +
Line 2205  static void mem_info_32(Monitor *mon, CP Line 2234  static void mem_info_32(Monitor *mon, CP
     last_prot = 0;      last_prot = 0;
     start = -1;      start = -1;
     for(l1 = 0; l1 < 1024; l1++) {      for(l1 = 0; l1 < 1024; l1++) {
         cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);          cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
         pde = le32_to_cpu(pde);          pde = le32_to_cpu(pde);
         end = l1 << 22;          end = l1 << 22;
         if (pde & PG_PRESENT_MASK) {          if (pde & PG_PRESENT_MASK) {
Line 2214  static void mem_info_32(Monitor *mon, CP Line 2243  static void mem_info_32(Monitor *mon, CP
                 mem_print(mon, &start, &last_prot, end, prot);                  mem_print(mon, &start, &last_prot, end, prot);
             } else {              } else {
                 for(l2 = 0; l2 < 1024; l2++) {                  for(l2 = 0; l2 < 1024; l2++) {
                     cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,                      cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
                                              (uint8_t *)&pte, 4);  
                     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) {
Line 2244  static void mem_info_pae32(Monitor *mon, Line 2272  static void mem_info_pae32(Monitor *mon,
     last_prot = 0;      last_prot = 0;
     start = -1;      start = -1;
     for (l1 = 0; l1 < 4; l1++) {      for (l1 = 0; l1 < 4; l1++) {
         cpu_physical_memory_read(pdp_addr + l1 * 8, (uint8_t *)&pdpe, 8);          cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
         pdpe = le64_to_cpu(pdpe);          pdpe = le64_to_cpu(pdpe);
         end = l1 << 30;          end = l1 << 30;
         if (pdpe & PG_PRESENT_MASK) {          if (pdpe & PG_PRESENT_MASK) {
             pd_addr = pdpe & 0x3fffffffff000ULL;              pd_addr = pdpe & 0x3fffffffff000ULL;
             for (l2 = 0; l2 < 512; l2++) {              for (l2 = 0; l2 < 512; l2++) {
                 cpu_physical_memory_read(pd_addr + l2 * 8,                  cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
                                          (uint8_t *)&pde, 8);  
                 pde = le64_to_cpu(pde);                  pde = le64_to_cpu(pde);
                 end = (l1 << 30) + (l2 << 21);                  end = (l1 << 30) + (l2 << 21);
                 if (pde & PG_PRESENT_MASK) {                  if (pde & PG_PRESENT_MASK) {
Line 2262  static void mem_info_pae32(Monitor *mon, Line 2289  static void mem_info_pae32(Monitor *mon,
                     } else {                      } else {
                         pt_addr = pde & 0x3fffffffff000ULL;                          pt_addr = pde & 0x3fffffffff000ULL;
                         for (l3 = 0; l3 < 512; l3++) {                          for (l3 = 0; l3 < 512; l3++) {
                             cpu_physical_memory_read(pt_addr + l3 * 8,                              cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
                                                      (uint8_t *)&pte, 8);  
                             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) {
Line 2300  static void mem_info_64(Monitor *mon, CP Line 2326  static void mem_info_64(Monitor *mon, CP
     last_prot = 0;      last_prot = 0;
     start = -1;      start = -1;
     for (l1 = 0; l1 < 512; l1++) {      for (l1 = 0; l1 < 512; l1++) {
         cpu_physical_memory_read(pml4_addr + l1 * 8, (uint8_t *)&pml4e, 8);          cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
         pml4e = le64_to_cpu(pml4e);          pml4e = le64_to_cpu(pml4e);
         end = l1 << 39;          end = l1 << 39;
         if (pml4e & PG_PRESENT_MASK) {          if (pml4e & PG_PRESENT_MASK) {
             pdp_addr = pml4e & 0x3fffffffff000ULL;              pdp_addr = pml4e & 0x3fffffffff000ULL;
             for (l2 = 0; l2 < 512; l2++) {              for (l2 = 0; l2 < 512; l2++) {
                 cpu_physical_memory_read(pdp_addr + l2 * 8, (uint8_t *)&pdpe,                  cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
                                          8);  
                 pdpe = le64_to_cpu(pdpe);                  pdpe = le64_to_cpu(pdpe);
                 end = (l1 << 39) + (l2 << 30);                  end = (l1 << 39) + (l2 << 30);
                 if (pdpe & PG_PRESENT_MASK) {                  if (pdpe & PG_PRESENT_MASK) {
Line 2318  static void mem_info_64(Monitor *mon, CP Line 2343  static void mem_info_64(Monitor *mon, CP
                     } else {                      } else {
                         pd_addr = pdpe & 0x3fffffffff000ULL;                          pd_addr = pdpe & 0x3fffffffff000ULL;
                         for (l3 = 0; l3 < 512; l3++) {                          for (l3 = 0; l3 < 512; l3++) {
                             cpu_physical_memory_read(pd_addr + l3 * 8,                              cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
                                                      (uint8_t *)&pde, 8);  
                             pde = le64_to_cpu(pde);                              pde = le64_to_cpu(pde);
                             end = (l1 << 39) + (l2 << 30) + (l3 << 21);                              end = (l1 << 39) + (l2 << 30) + (l3 << 21);
                             if (pde & PG_PRESENT_MASK) {                              if (pde & PG_PRESENT_MASK) {
Line 2332  static void mem_info_64(Monitor *mon, CP Line 2356  static void mem_info_64(Monitor *mon, CP
                                     for (l4 = 0; l4 < 512; l4++) {                                      for (l4 = 0; l4 < 512; l4++) {
                                         cpu_physical_memory_read(pt_addr                                          cpu_physical_memory_read(pt_addr
                                                                  + l4 * 8,                                                                   + l4 * 8,
                                                                  (uint8_t *)&pte,                                                                   &pte, 8);
                                                                  8);  
                                         pte = le64_to_cpu(pte);                                          pte = le64_to_cpu(pte);
                                         end = (l1 << 39) + (l2 << 30) +                                          end = (l1 << 39) + (l2 << 30) +
                                             (l3 << 21) + (l4 << 12);                                              (l3 << 21) + (l4 << 12);
Line 2555  static void do_wav_capture(Monitor *mon, Line 2578  static void do_wav_capture(Monitor *mon,
 #endif  #endif
   
 #if defined(TARGET_I386)  #if defined(TARGET_I386)
 static void do_inject_nmi(Monitor *mon, const QDict *qdict)  static int do_inject_nmi(Monitor *mon, const QDict *qdict, QObject **ret_data)
 {  {
     CPUState *env;      CPUState *env;
     int cpu_index = qdict_get_int(qdict, "cpu_index");  
   
     for (env = first_cpu; env != NULL; env = env->next_cpu)      for (env = first_cpu; env != NULL; env = env->next_cpu) {
         if (env->cpu_index == cpu_index) {          cpu_interrupt(env, CPU_INTERRUPT_NMI);
             cpu_interrupt(env, CPU_INTERRUPT_NMI);      }
             break;  
         }      return 0;
   }
   #else
   static int do_inject_nmi(Monitor *mon, const QDict *qdict, QObject **ret_data)
   {
       qerror_report(QERR_UNSUPPORTED);
       return -1;
 }  }
 #endif  #endif
   
Line 2709  static void do_inject_mce(Monitor *mon,  Line 2737  static void do_inject_mce(Monitor *mon, 
     uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");      uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
     uint64_t addr = qdict_get_int(qdict, "addr");      uint64_t addr = qdict_get_int(qdict, "addr");
     uint64_t misc = qdict_get_int(qdict, "misc");      uint64_t misc = qdict_get_int(qdict, "misc");
     int broadcast = qdict_get_try_bool(qdict, "broadcast", 0);      int flags = MCE_INJECT_UNCOND_AO;
   
       if (qdict_get_try_bool(qdict, "broadcast", 0)) {
           flags |= MCE_INJECT_BROADCAST;
       }
     for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu) {      for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu) {
         if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {          if (cenv->cpu_index == cpu_index) {
             cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc,              cpu_x86_inject_mce(mon, cenv, bank, status, mcg_status, addr, misc,
                                broadcast);                                 flags);
             break;              break;
         }          }
     }      }
Line 2783  static void do_loadvm(Monitor *mon, cons Line 2814  static void do_loadvm(Monitor *mon, cons
     int saved_vm_running  = vm_running;      int saved_vm_running  = vm_running;
     const char *name = qdict_get_str(qdict, "name");      const char *name = qdict_get_str(qdict, "name");
   
     vm_stop(0);      vm_stop(VMSTOP_LOADVM);
   
     if (load_vmstate(name) == 0 && saved_vm_running) {      if (load_vmstate(name) == 0 && saved_vm_running) {
         vm_start();          vm_start();
Line 3457  static const MonitorDef monitor_defs[] = Line 3488  static const MonitorDef monitor_defs[] =
     { "asr", offsetof(CPUState, asr) },      { "asr", offsetof(CPUState, asr) },
 #endif  #endif
     /* Segment registers */      /* Segment registers */
     { "sdr1", offsetof(CPUState, sdr1) },      { "sdr1", offsetof(CPUState, spr[SPR_SDR1]) },
     { "sr0", offsetof(CPUState, sr[0]) },      { "sr0", offsetof(CPUState, sr[0]) },
     { "sr1", offsetof(CPUState, sr[1]) },      { "sr1", offsetof(CPUState, sr[1]) },
     { "sr2", offsetof(CPUState, sr[2]) },      { "sr2", offsetof(CPUState, sr[2]) },
Line 3474  static const MonitorDef monitor_defs[] = Line 3505  static const MonitorDef monitor_defs[] =
     { "sr13", offsetof(CPUState, sr[13]) },      { "sr13", offsetof(CPUState, sr[13]) },
     { "sr14", offsetof(CPUState, sr[14]) },      { "sr14", offsetof(CPUState, sr[14]) },
     { "sr15", offsetof(CPUState, sr[15]) },      { "sr15", offsetof(CPUState, sr[15]) },
     /* Too lazy to put BATs and SPRs ... */      /* Too lazy to put BATs... */
       { "pvr", offsetof(CPUState, spr[SPR_PVR]) },
   
       { "srr0", offsetof(CPUState, spr[SPR_SRR0]) },
       { "srr1", offsetof(CPUState, spr[SPR_SRR1]) },
       { "sprg0", offsetof(CPUState, spr[SPR_SPRG0]) },
       { "sprg1", offsetof(CPUState, spr[SPR_SPRG1]) },
       { "sprg2", offsetof(CPUState, spr[SPR_SPRG2]) },
       { "sprg3", offsetof(CPUState, spr[SPR_SPRG3]) },
       { "sprg4", offsetof(CPUState, spr[SPR_SPRG4]) },
       { "sprg5", offsetof(CPUState, spr[SPR_SPRG5]) },
       { "sprg6", offsetof(CPUState, spr[SPR_SPRG6]) },
       { "sprg7", offsetof(CPUState, spr[SPR_SPRG7]) },
       { "pid", offsetof(CPUState, spr[SPR_BOOKE_PID]) },
       { "csrr0", offsetof(CPUState, spr[SPR_BOOKE_CSRR0]) },
       { "csrr1", offsetof(CPUState, spr[SPR_BOOKE_CSRR1]) },
       { "esr", offsetof(CPUState, spr[SPR_BOOKE_ESR]) },
       { "dear", offsetof(CPUState, spr[SPR_BOOKE_DEAR]) },
       { "mcsr", offsetof(CPUState, spr[SPR_BOOKE_MCSR]) },
       { "tsr", offsetof(CPUState, spr[SPR_BOOKE_TSR]) },
       { "tcr", offsetof(CPUState, spr[SPR_BOOKE_TCR]) },
       { "vrsave", offsetof(CPUState, spr[SPR_VRSAVE]) },
       { "pir", offsetof(CPUState, spr[SPR_BOOKE_PIR]) },
       { "mcsrr0", offsetof(CPUState, spr[SPR_BOOKE_MCSRR0]) },
       { "mcsrr1", offsetof(CPUState, spr[SPR_BOOKE_MCSRR1]) },
       { "decar", offsetof(CPUState, spr[SPR_BOOKE_DECAR]) },
       { "ivpr", offsetof(CPUState, spr[SPR_BOOKE_IVPR]) },
       { "epcr", offsetof(CPUState, spr[SPR_BOOKE_EPCR]) },
       { "sprg8", offsetof(CPUState, spr[SPR_BOOKE_SPRG8]) },
       { "ivor0", offsetof(CPUState, spr[SPR_BOOKE_IVOR0]) },
       { "ivor1", offsetof(CPUState, spr[SPR_BOOKE_IVOR1]) },
       { "ivor2", offsetof(CPUState, spr[SPR_BOOKE_IVOR2]) },
       { "ivor3", offsetof(CPUState, spr[SPR_BOOKE_IVOR3]) },
       { "ivor4", offsetof(CPUState, spr[SPR_BOOKE_IVOR4]) },
       { "ivor5", offsetof(CPUState, spr[SPR_BOOKE_IVOR5]) },
       { "ivor6", offsetof(CPUState, spr[SPR_BOOKE_IVOR6]) },
       { "ivor7", offsetof(CPUState, spr[SPR_BOOKE_IVOR7]) },
       { "ivor8", offsetof(CPUState, spr[SPR_BOOKE_IVOR8]) },
       { "ivor9", offsetof(CPUState, spr[SPR_BOOKE_IVOR9]) },
       { "ivor10", offsetof(CPUState, spr[SPR_BOOKE_IVOR10]) },
       { "ivor11", offsetof(CPUState, spr[SPR_BOOKE_IVOR11]) },
       { "ivor12", offsetof(CPUState, spr[SPR_BOOKE_IVOR12]) },
       { "ivor13", offsetof(CPUState, spr[SPR_BOOKE_IVOR13]) },
       { "ivor14", offsetof(CPUState, spr[SPR_BOOKE_IVOR14]) },
       { "ivor15", offsetof(CPUState, spr[SPR_BOOKE_IVOR15]) },
       { "ivor32", offsetof(CPUState, spr[SPR_BOOKE_IVOR32]) },
       { "ivor33", offsetof(CPUState, spr[SPR_BOOKE_IVOR33]) },
       { "ivor34", offsetof(CPUState, spr[SPR_BOOKE_IVOR34]) },
       { "ivor35", offsetof(CPUState, spr[SPR_BOOKE_IVOR35]) },
       { "ivor36", offsetof(CPUState, spr[SPR_BOOKE_IVOR36]) },
       { "ivor37", offsetof(CPUState, spr[SPR_BOOKE_IVOR37]) },
       { "mas0", offsetof(CPUState, spr[SPR_BOOKE_MAS0]) },
       { "mas1", offsetof(CPUState, spr[SPR_BOOKE_MAS1]) },
       { "mas2", offsetof(CPUState, spr[SPR_BOOKE_MAS2]) },
       { "mas3", offsetof(CPUState, spr[SPR_BOOKE_MAS3]) },
       { "mas4", offsetof(CPUState, spr[SPR_BOOKE_MAS4]) },
       { "mas6", offsetof(CPUState, spr[SPR_BOOKE_MAS6]) },
       { "mas7", offsetof(CPUState, spr[SPR_BOOKE_MAS7]) },
       { "mmucfg", offsetof(CPUState, spr[SPR_MMUCFG]) },
       { "tlb0cfg", offsetof(CPUState, spr[SPR_BOOKE_TLB0CFG]) },
       { "tlb1cfg", offsetof(CPUState, spr[SPR_BOOKE_TLB1CFG]) },
       { "epr", offsetof(CPUState, spr[SPR_BOOKE_EPR]) },
       { "eplc", offsetof(CPUState, spr[SPR_BOOKE_EPLC]) },
       { "epsc", offsetof(CPUState, spr[SPR_BOOKE_EPSC]) },
       { "svr", offsetof(CPUState, spr[SPR_E500_SVR]) },
       { "mcar", offsetof(CPUState, spr[SPR_Exxx_MCAR]) },
       { "pid1", offsetof(CPUState, spr[SPR_BOOKE_PID1]) },
       { "pid2", offsetof(CPUState, spr[SPR_BOOKE_PID2]) },
       { "hid0", offsetof(CPUState, spr[SPR_HID0]) },
   
 #elif defined(TARGET_SPARC)  #elif defined(TARGET_SPARC)
     { "g0", offsetof(CPUState, gregs[0]) },      { "g0", offsetof(CPUState, gregs[0]) },
     { "g1", offsetof(CPUState, gregs[1]) },      { "g1", offsetof(CPUState, gregs[1]) },
Line 5157  void monitor_init(CharDriverState *chr,  Line 5257  void monitor_init(CharDriverState *chr, 
     Monitor *mon;      Monitor *mon;
   
     if (is_first_init) {      if (is_first_init) {
         key_timer = qemu_new_timer(vm_clock, release_keys, NULL);          key_timer = qemu_new_timer_ns(vm_clock, release_keys, NULL);
         is_first_init = 0;          is_first_init = 0;
     }      }
   

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


unix.superglobalmegacorp.com