Diff for /qemu/gdbstub.c between versions 1.1.1.12 and 1.1.1.13

version 1.1.1.12, 2018/04/24 18:55:33 version 1.1.1.13, 2018/04/24 19:16:34
Line 41 Line 41
 #include "qemu_socket.h"  #include "qemu_socket.h"
 #include "kvm.h"  #include "kvm.h"
   
   #ifndef TARGET_CPU_MEMORY_RW_DEBUG
   static inline int target_memory_rw_debug(CPUState *env, target_ulong addr,
                                            uint8_t *buf, int len, int is_write)
   {
       return cpu_memory_rw_debug(env, addr, buf, len, is_write);
   }
   #else
   /* target_memory_rw_debug() defined in cpu.h */
   #endif
   
 enum {  enum {
     GDB_SIGNAL_0 = 0,      GDB_SIGNAL_0 = 0,
Line 382  static void put_buffer(GDBState *s, cons Line 391  static void put_buffer(GDBState *s, cons
         }          }
     }      }
 #else  #else
     qemu_chr_write(s->chr, buf, len);      qemu_chr_fe_write(s->chr, buf, len);
 #endif  #endif
 }  }
   
Line 724  static int cpu_gdb_read_register(CPUStat Line 733  static int cpu_gdb_read_register(CPUStat
             {              {
                 if (gdb_has_xml)                  if (gdb_has_xml)
                     return 0;                      return 0;
                 GET_REG32(0); /* fpscr */                  GET_REG32(env->fpscr);
             }              }
         }          }
     }      }
Line 805  static int cpu_gdb_read_register(CPUStat Line 814  static int cpu_gdb_read_register(CPUStat
 #if defined(TARGET_ABI32) || !defined(TARGET_SPARC64)  #if defined(TARGET_ABI32) || !defined(TARGET_SPARC64)
     if (n < 64) {      if (n < 64) {
         /* fprs */          /* fprs */
         GET_REG32(*((uint32_t *)&env->fpr[n - 32]));          if (n & 1) {
               GET_REG32(env->fpr[(n - 32) / 2].l.lower);
           } else {
               GET_REG32(env->fpr[(n - 32) / 2].l.upper);
           }
     }      }
     /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */      /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
     switch (n) {      switch (n) {
Line 822  static int cpu_gdb_read_register(CPUStat Line 835  static int cpu_gdb_read_register(CPUStat
 #else  #else
     if (n < 64) {      if (n < 64) {
         /* f0-f31 */          /* f0-f31 */
         GET_REG32(*((uint32_t *)&env->fpr[n - 32]));          if (n & 1) {
               GET_REG32(env->fpr[(n - 32) / 2].l.lower);
           } else {
               GET_REG32(env->fpr[(n - 32) / 2].l.upper);
           }
     }      }
     if (n < 80) {      if (n < 80) {
         /* f32-f62 (double width, even numbers only) */          /* f32-f62 (double width, even numbers only) */
         uint64_t val;          GET_REG64(env->fpr[(n - 32) / 2].ll);
   
         val = (uint64_t)*((uint32_t *)&env->fpr[(n - 64) * 2 + 32]) << 32;  
         val |= *((uint32_t *)&env->fpr[(n - 64) * 2 + 33]);  
         GET_REG64(val);  
     }      }
     switch (n) {      switch (n) {
     case 80: GET_REGL(env->pc);      case 80: GET_REGL(env->pc);
Line 869  static int cpu_gdb_write_register(CPUSta Line 882  static int cpu_gdb_write_register(CPUSta
 #if defined(TARGET_ABI32) || !defined(TARGET_SPARC64)  #if defined(TARGET_ABI32) || !defined(TARGET_SPARC64)
     else if (n < 64) {      else if (n < 64) {
         /* fprs */          /* fprs */
         *((uint32_t *)&env->fpr[n - 32]) = tmp;          /* f0-f31 */
           if (n & 1) {
               env->fpr[(n - 32) / 2].l.lower = tmp;
           } else {
               env->fpr[(n - 32) / 2].l.upper = tmp;
           }
     } else {      } else {
         /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */          /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
         switch (n) {          switch (n) {
Line 887  static int cpu_gdb_write_register(CPUSta Line 905  static int cpu_gdb_write_register(CPUSta
 #else  #else
     else if (n < 64) {      else if (n < 64) {
         /* f0-f31 */          /* f0-f31 */
         env->fpr[n] = ldfl_p(mem_buf);          tmp = ldl_p(mem_buf);
           if (n & 1) {
               env->fpr[(n - 32) / 2].l.lower = tmp;
           } else {
               env->fpr[(n - 32) / 2].l.upper = tmp;
           }
         return 4;          return 4;
     } else if (n < 80) {      } else if (n < 80) {
         /* f32-f62 (double width, even numbers only) */          /* f32-f62 (double width, even numbers only) */
         *((uint32_t *)&env->fpr[(n - 64) * 2 + 32]) = tmp >> 32;          env->fpr[(n - 32) / 2].ll = tmp;
         *((uint32_t *)&env->fpr[(n - 64) * 2 + 33]) = tmp;  
     } else {      } else {
         switch (n) {          switch (n) {
         case 80: env->pc = tmp; break;          case 80: env->pc = tmp; break;
Line 1541  static int cpu_gdb_write_register(CPUSta Line 1563  static int cpu_gdb_write_register(CPUSta
     }      }
     return 4;      return 4;
 }  }
   #elif defined(TARGET_XTENSA)
   
   /* Use num_core_regs to see only non-privileged registers in an unmodified gdb.
    * Use num_regs to see all registers. gdb modification is required for that:
    * reset bit 0 in the 'flags' field of the registers definitions in the
    * gdb/xtensa-config.c inside gdb source tree or inside gdb overlay.
    */
   #define NUM_CORE_REGS (env->config->gdb_regmap.num_regs)
   #define num_g_regs NUM_CORE_REGS
   
   static int cpu_gdb_read_register(CPUState *env, uint8_t *mem_buf, int n)
   {
       const XtensaGdbReg *reg = env->config->gdb_regmap.reg + n;
   
       if (n < 0 || n >= env->config->gdb_regmap.num_regs) {
           return 0;
       }
   
       switch (reg->type) {
       case 9: /*pc*/
           GET_REG32(env->pc);
           break;
   
       case 1: /*ar*/
           xtensa_sync_phys_from_window(env);
           GET_REG32(env->phys_regs[(reg->targno & 0xff) % env->config->nareg]);
           break;
   
       case 2: /*SR*/
           GET_REG32(env->sregs[reg->targno & 0xff]);
           break;
   
       case 3: /*UR*/
           GET_REG32(env->uregs[reg->targno & 0xff]);
           break;
   
       case 8: /*a*/
           GET_REG32(env->regs[reg->targno & 0x0f]);
           break;
   
       default:
           qemu_log("%s from reg %d of unsupported type %d\n",
                   __func__, n, reg->type);
           return 0;
       }
   }
   
   static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
   {
       uint32_t tmp;
       const XtensaGdbReg *reg = env->config->gdb_regmap.reg + n;
   
       if (n < 0 || n >= env->config->gdb_regmap.num_regs) {
           return 0;
       }
   
       tmp = ldl_p(mem_buf);
   
       switch (reg->type) {
       case 9: /*pc*/
           env->pc = tmp;
           break;
   
       case 1: /*ar*/
           env->phys_regs[(reg->targno & 0xff) % env->config->nareg] = tmp;
           xtensa_sync_window_from_phys(env);
           break;
   
       case 2: /*SR*/
           env->sregs[reg->targno & 0xff] = tmp;
           break;
   
       case 3: /*UR*/
           env->uregs[reg->targno & 0xff] = tmp;
           break;
   
       case 8: /*a*/
           env->regs[reg->targno & 0x0f] = tmp;
           break;
   
       default:
           qemu_log("%s to reg %d of unsupported type %d\n",
                   __func__, n, reg->type);
           return 0;
       }
   
       return 4;
   }
 #else  #else
   
 #define NUM_CORE_REGS 0  #define NUM_CORE_REGS 0
Line 1557  static int cpu_gdb_write_register(CPUSta Line 1667  static int cpu_gdb_write_register(CPUSta
   
 #endif  #endif
   
   #if !defined(TARGET_XTENSA)
 static int num_g_regs = NUM_CORE_REGS;  static int num_g_regs = NUM_CORE_REGS;
   #endif
   
 #ifdef GDB_CORE_XML  #ifdef GDB_CORE_XML
 /* Encode data using the encoding for 'x' packets.  */  /* Encode data using the encoding for 'x' packets.  */
Line 1654  static int gdb_write_register(CPUState * Line 1766  static int gdb_write_register(CPUState *
     return 0;      return 0;
 }  }
   
   #if !defined(TARGET_XTENSA)
 /* Register a supplemental set of CPU registers.  If g_pos is nonzero it  /* Register a supplemental set of CPU registers.  If g_pos is nonzero it
    specifies the first register number and these registers are included in     specifies the first register number and these registers are included in
    a standard "g" packet.  Direction is relative to gdb, i.e. get_reg is     a standard "g" packet.  Direction is relative to gdb, i.e. get_reg is
Line 1668  void gdb_register_coprocessor(CPUState * Line 1781  void gdb_register_coprocessor(CPUState *
     GDBRegisterState **p;      GDBRegisterState **p;
     static int last_reg = NUM_CORE_REGS;      static int last_reg = NUM_CORE_REGS;
   
     s = (GDBRegisterState *)qemu_mallocz(sizeof(GDBRegisterState));  
     s->base_reg = last_reg;  
     s->num_regs = num_regs;  
     s->get_reg = get_reg;  
     s->set_reg = set_reg;  
     s->xml = xml;  
     p = &env->gdb_regs;      p = &env->gdb_regs;
     while (*p) {      while (*p) {
         /* Check for duplicates.  */          /* Check for duplicates.  */
Line 1681  void gdb_register_coprocessor(CPUState * Line 1788  void gdb_register_coprocessor(CPUState *
             return;              return;
         p = &(*p)->next;          p = &(*p)->next;
     }      }
   
       s = g_new0(GDBRegisterState, 1);
       s->base_reg = last_reg;
       s->num_regs = num_regs;
       s->get_reg = get_reg;
       s->set_reg = set_reg;
       s->xml = xml;
   
     /* Add to end of list.  */      /* Add to end of list.  */
     last_reg += num_regs;      last_reg += num_regs;
     *p = s;      *p = s;
Line 1693  void gdb_register_coprocessor(CPUState * Line 1808  void gdb_register_coprocessor(CPUState *
         }          }
     }      }
 }  }
   #endif
   
 #ifndef CONFIG_USER_ONLY  #ifndef CONFIG_USER_ONLY
 static const int xlat_gdb_type[] = {  static const int xlat_gdb_type[] = {
Line 1818  static void gdb_set_cpu_pc(GDBState *s,  Line 1934  static void gdb_set_cpu_pc(GDBState *s, 
     s->c_cpu->psw.addr = pc;      s->c_cpu->psw.addr = pc;
 #elif defined (TARGET_LM32)  #elif defined (TARGET_LM32)
     s->c_cpu->pc = pc;      s->c_cpu->pc = pc;
   #elif defined(TARGET_XTENSA)
       s->c_cpu->pc = pc;
 #endif  #endif
 }  }
   
Line 1988  static int gdb_handle_packet(GDBState *s Line 2106  static int gdb_handle_packet(GDBState *s
         break;          break;
     case 'g':      case 'g':
         cpu_synchronize_state(s->g_cpu);          cpu_synchronize_state(s->g_cpu);
           env = s->g_cpu;
         len = 0;          len = 0;
         for (addr = 0; addr < num_g_regs; addr++) {          for (addr = 0; addr < num_g_regs; addr++) {
             reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);              reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
Line 1998  static int gdb_handle_packet(GDBState *s Line 2117  static int gdb_handle_packet(GDBState *s
         break;          break;
     case 'G':      case 'G':
         cpu_synchronize_state(s->g_cpu);          cpu_synchronize_state(s->g_cpu);
           env = s->g_cpu;
         registers = mem_buf;          registers = mem_buf;
         len = strlen(p) / 2;          len = strlen(p) / 2;
         hextomem((uint8_t *)registers, p, len);          hextomem((uint8_t *)registers, p, len);
Line 2013  static int gdb_handle_packet(GDBState *s Line 2133  static int gdb_handle_packet(GDBState *s
         if (*p == ',')          if (*p == ',')
             p++;              p++;
         len = strtoull(p, NULL, 16);          len = strtoull(p, NULL, 16);
         if (cpu_memory_rw_debug(s->g_cpu, addr, mem_buf, len, 0) != 0) {          if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, 0) != 0) {
             put_packet (s, "E14");              put_packet (s, "E14");
         } else {          } else {
             memtohex(buf, mem_buf, len);              memtohex(buf, mem_buf, len);
Line 2028  static int gdb_handle_packet(GDBState *s Line 2148  static int gdb_handle_packet(GDBState *s
         if (*p == ':')          if (*p == ':')
             p++;              p++;
         hextomem(mem_buf, p, len);          hextomem(mem_buf, p, len);
         if (cpu_memory_rw_debug(s->g_cpu, addr, mem_buf, len, 1) != 0)          if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, 1) != 0) {
             put_packet(s, "E14");              put_packet(s, "E14");
         else          } else {
             put_packet(s, "OK");              put_packet(s, "OK");
           }
         break;          break;
     case 'p':      case 'p':
         /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.          /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
Line 2194  static int gdb_handle_packet(GDBState *s Line 2315  static int gdb_handle_packet(GDBState *s
             hextomem(mem_buf, p + 5, len);              hextomem(mem_buf, p + 5, len);
             len = len / 2;              len = len / 2;
             mem_buf[len++] = 0;              mem_buf[len++] = 0;
             qemu_chr_read(s->mon_chr, mem_buf, len);              qemu_chr_be_write(s->mon_chr, mem_buf, len);
             put_packet(s, "OK");              put_packet(s, "OK");
             break;              break;
         }          }
Line 2267  void gdb_set_stop_cpu(CPUState *env) Line 2388  void gdb_set_stop_cpu(CPUState *env)
 }  }
   
 #ifndef CONFIG_USER_ONLY  #ifndef CONFIG_USER_ONLY
 static void gdb_vm_state_change(void *opaque, int running, int reason)  static void gdb_vm_state_change(void *opaque, int running, RunState state)
 {  {
     GDBState *s = gdbserver_state;      GDBState *s = gdbserver_state;
     CPUState *env = s->c_cpu;      CPUState *env = s->c_cpu;
Line 2278  static void gdb_vm_state_change(void *op Line 2399  static void gdb_vm_state_change(void *op
     if (running || s->state == RS_INACTIVE || s->state == RS_SYSCALL) {      if (running || s->state == RS_INACTIVE || s->state == RS_SYSCALL) {
         return;          return;
     }      }
     switch (reason) {      switch (state) {
     case VMSTOP_DEBUG:      case RUN_STATE_DEBUG:
         if (env->watchpoint_hit) {          if (env->watchpoint_hit) {
             switch (env->watchpoint_hit->flags & BP_MEM_ACCESS) {              switch (env->watchpoint_hit->flags & BP_MEM_ACCESS) {
             case BP_MEM_READ:              case BP_MEM_READ:
Line 2302  static void gdb_vm_state_change(void *op Line 2423  static void gdb_vm_state_change(void *op
         tb_flush(env);          tb_flush(env);
         ret = GDB_SIGNAL_TRAP;          ret = GDB_SIGNAL_TRAP;
         break;          break;
     case VMSTOP_USER:      case RUN_STATE_PAUSED:
         ret = GDB_SIGNAL_INT;          ret = GDB_SIGNAL_INT;
         break;          break;
     case VMSTOP_SHUTDOWN:      case RUN_STATE_SHUTDOWN:
         ret = GDB_SIGNAL_QUIT;          ret = GDB_SIGNAL_QUIT;
         break;          break;
     case VMSTOP_DISKFULL:      case RUN_STATE_IO_ERROR:
         ret = GDB_SIGNAL_IO;          ret = GDB_SIGNAL_IO;
         break;          break;
     case VMSTOP_WATCHDOG:      case RUN_STATE_WATCHDOG:
         ret = GDB_SIGNAL_ALRM;          ret = GDB_SIGNAL_ALRM;
         break;          break;
     case VMSTOP_PANIC:      case RUN_STATE_INTERNAL_ERROR:
         ret = GDB_SIGNAL_ABRT;          ret = GDB_SIGNAL_ABRT;
         break;          break;
     case VMSTOP_SAVEVM:      case RUN_STATE_SAVE_VM:
     case VMSTOP_LOADVM:      case RUN_STATE_RESTORE_VM:
         return;          return;
     case VMSTOP_MIGRATE:      case RUN_STATE_FINISH_MIGRATE:
         ret = GDB_SIGNAL_XCPU;          ret = GDB_SIGNAL_XCPU;
         break;          break;
     default:      default:
Line 2357  void gdb_do_syscall(gdb_syscall_complete Line 2478  void gdb_do_syscall(gdb_syscall_complete
     gdb_current_syscall_cb = cb;      gdb_current_syscall_cb = cb;
     s->state = RS_SYSCALL;      s->state = RS_SYSCALL;
 #ifndef CONFIG_USER_ONLY  #ifndef CONFIG_USER_ONLY
     vm_stop(VMSTOP_DEBUG);      vm_stop(RUN_STATE_DEBUG);
 #endif  #endif
     s->state = RS_IDLE;      s->state = RS_IDLE;
     va_start(va, fmt);      va_start(va, fmt);
Line 2428  static void gdb_read_byte(GDBState *s, i Line 2549  static void gdb_read_byte(GDBState *s, i
         if (ch != '$')          if (ch != '$')
             return;              return;
     }      }
     if (vm_running) {      if (runstate_is_running()) {
         /* when the CPU is running, we cannot do anything except stop          /* when the CPU is running, we cannot do anything except stop
            it when receiving a char */             it when receiving a char */
         vm_stop(VMSTOP_USER);          vm_stop(RUN_STATE_PAUSED);
     } else      } else
 #endif  #endif
     {      {
Line 2499  void gdb_exit(CPUState *env, int code) Line 2620  void gdb_exit(CPUState *env, int code)
   
 #ifndef CONFIG_USER_ONLY  #ifndef CONFIG_USER_ONLY
   if (s->chr) {    if (s->chr) {
       qemu_chr_close(s->chr);        qemu_chr_delete(s->chr);
   }    }
 #endif  #endif
 }  }
Line 2606  static void gdb_accept(void) Line 2727  static void gdb_accept(void)
     val = 1;      val = 1;
     setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));      setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
   
     s = qemu_mallocz(sizeof(GDBState));      s = g_malloc0(sizeof(GDBState));
     s->c_cpu = first_cpu;      s->c_cpu = first_cpu;
     s->g_cpu = first_cpu;      s->g_cpu = first_cpu;
     s->fd = fd;      s->fd = fd;
Line 2693  static void gdb_chr_event(void *opaque,  Line 2814  static void gdb_chr_event(void *opaque, 
 {  {
     switch (event) {      switch (event) {
     case CHR_EVENT_OPENED:      case CHR_EVENT_OPENED:
         vm_stop(VMSTOP_USER);          vm_stop(RUN_STATE_PAUSED);
         gdb_has_xml = 0;          gdb_has_xml = 0;
         break;          break;
     default:      default:
Line 2733  static int gdb_monitor_write(CharDriverS Line 2854  static int gdb_monitor_write(CharDriverS
 #ifndef _WIN32  #ifndef _WIN32
 static void gdb_sigterm_handler(int signal)  static void gdb_sigterm_handler(int signal)
 {  {
     if (vm_running) {      if (runstate_is_running()) {
         vm_stop(VMSTOP_USER);          vm_stop(RUN_STATE_PAUSED);
     }      }
 }  }
 #endif  #endif
Line 2764  int gdbserver_start(const char *device) Line 2885  int gdbserver_start(const char *device)
             sigaction(SIGINT, &act, NULL);              sigaction(SIGINT, &act, NULL);
         }          }
 #endif  #endif
         chr = qemu_chr_open("gdb", device, NULL);          chr = qemu_chr_new("gdb", device, NULL);
         if (!chr)          if (!chr)
             return -1;              return -1;
   
Line 2774  int gdbserver_start(const char *device) Line 2895  int gdbserver_start(const char *device)
   
     s = gdbserver_state;      s = gdbserver_state;
     if (!s) {      if (!s) {
         s = qemu_mallocz(sizeof(GDBState));          s = g_malloc0(sizeof(GDBState));
         gdbserver_state = s;          gdbserver_state = s;
   
         qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);          qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
   
         /* Initialize a monitor terminal for gdb */          /* Initialize a monitor terminal for gdb */
         mon_chr = qemu_mallocz(sizeof(*mon_chr));          mon_chr = g_malloc0(sizeof(*mon_chr));
         mon_chr->chr_write = gdb_monitor_write;          mon_chr->chr_write = gdb_monitor_write;
         monitor_init(mon_chr, 0);          monitor_init(mon_chr, 0);
     } else {      } else {
         if (s->chr)          if (s->chr)
             qemu_chr_close(s->chr);              qemu_chr_delete(s->chr);
         mon_chr = s->mon_chr;          mon_chr = s->mon_chr;
         memset(s, 0, sizeof(GDBState));          memset(s, 0, sizeof(GDBState));
     }      }

Removed from v.1.1.1.12  
changed lines
  Added in v.1.1.1.13


unix.superglobalmegacorp.com