gdb/gdbserver/server.c

   1 /* Main code for remote server for GDB.
   2    Copyright (C) 1989-2017 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "server.h"
  20 #include "gdbthread.h"
  21 #include "agent.h"
  22 #include "notif.h"
  23 #include "tdesc.h"
  24 #include "rsp-low.h"
  25 #include "signals-state-save-restore.h"
  26 #include <ctype.h>
  27 #include <unistd.h>
  28 #if HAVE_SIGNAL_H
  29 #include <signal.h>
  30 #endif
  31 #include "gdb_vecs.h"
  32 #include "gdb_wait.h"
  33 #include "btrace-common.h"
  34 #include "filestuff.h"
  35 #include "tracepoint.h"
  36 #include "dll.h"
  37 #include "hostio.h"
  38 #include <vector>
  39 #include "common-inferior.h"
  40 #include "job-control.h"
  41 #include "environ.h"
  42
  43 #include "common/selftest.h"
  44
  45 #define require_running_or_return(BUF)          \
  46   if (!target_running ())                       \
  47     {                                           \
  48       write_enn (BUF);                          \
  49       return;                                   \
  50     }
  51
  52 #define require_running_or_break(BUF)           \
  53   if (!target_running ())                       \
  54     {                                           \
  55       write_enn (BUF);                          \
  56       break;                                    \
  57     }
  58
  59 /* The environment to pass to the inferior when creating it.  */
  60
  61 static gdb_environ our_environ;
  62
  63 /* Start the inferior using a shell.  */
  64
  65 /* We always try to start the inferior using a shell.  */
  66
  67 int startup_with_shell = 1;
  68
  69 /* The thread set with an `Hc' packet.  `Hc' is deprecated in favor of
  70    `vCont'.  Note the multi-process extensions made `vCont' a
  71    requirement, so `Hc pPID.TID' is pretty much undefined.  So
  72    CONT_THREAD can be null_ptid for no `Hc' thread, minus_one_ptid for
  73    resuming all threads of the process (again, `Hc' isn't used for
  74    multi-process), or a specific thread ptid_t.  */
  75 ptid_t cont_thread;
  76
  77 /* The thread set with an `Hg' packet.  */
  78 ptid_t general_thread;
  79
  80 int server_waiting;
  81
  82 static int extended_protocol;
  83 static int response_needed;
  84 static int exit_requested;
  85
  86 /* --once: Exit after the first connection has closed.  */
  87 int run_once;
  88
  89 int multi_process;
  90 int report_fork_events;
  91 int report_vfork_events;
  92 int report_exec_events;
  93 int report_thread_events;
  94
  95 /* Whether to report TARGET_WAITKING_NO_RESUMED events.  */
  96 static int report_no_resumed;
  97
  98 int non_stop;
  99 int swbreak_feature;
 100 int hwbreak_feature;
 101
 102 /* True if the "vContSupported" feature is active.  In that case, GDB
 103    wants us to report whether single step is supported in the reply to
 104    "vCont?" packet.  */
 105 static int vCont_supported;
 106
 107 /* Whether we should attempt to disable the operating system's address
 108    space randomization feature before starting an inferior.  */
 109 int disable_randomization = 1;
 110
 111 static char *program_name = NULL;
 112 static std::vector<char *> program_args;
 113 static std::string wrapper_argv;
 114
 115 int pass_signals[GDB_SIGNAL_LAST];
 116 int program_signals[GDB_SIGNAL_LAST];
 117 int program_signals_p;
 118
 119 /* The PID of the originally created or attached inferior.  Used to
 120    send signals to the process when GDB sends us an asynchronous interrupt
 121    (user hitting Control-C in the client), and to wait for the child to exit
 122    when no longer debugging it.  */
 123
 124 unsigned long signal_pid;
 125
 126 /* Set if you want to disable optional thread related packets support
 127    in gdbserver, for the sake of testing GDB against stubs that don't
 128    support them.  */
 129 int disable_packet_vCont;
 130 int disable_packet_Tthread;
 131 int disable_packet_qC;
 132 int disable_packet_qfThreadInfo;
 133
 134 /* Last status reported to GDB.  */
 135 struct target_waitstatus last_status;
 136 ptid_t last_ptid;
 137
 138 char *own_buf;
 139 static unsigned char *mem_buf;
 140
 141 /* A sub-class of 'struct notif_event' for stop, holding information
 142    relative to a single stop reply.  We keep a queue of these to
 143    push to GDB in non-stop mode.  */
 144
 145 struct vstop_notif
 146 {
 147   struct notif_event base;
 148
 149   /* Thread or process that got the event.  */
 150   ptid_t ptid;
 151
 152   /* Event info.  */
 153   struct target_waitstatus status;
 154 };
 155
 156 /* The current btrace configuration.  This is gdbserver's mirror of GDB's
 157    btrace configuration.  */
 158 static struct btrace_config current_btrace_conf;
 159
 160 DEFINE_QUEUE_P (notif_event_p);
 161
 162 /* Put a stop reply to the stop reply queue.  */
 163
 164 static void
 165 queue_stop_reply (ptid_t ptid, struct target_waitstatus *status)
 166 {
 167   struct vstop_notif *new_notif = XNEW (struct vstop_notif);
 168
 169   new_notif->ptid = ptid;
 170   new_notif->status = *status;
 171
 172   notif_event_enque (&notif_stop, (struct notif_event *) new_notif);
 173 }
 174
 175 static int
 176 remove_all_on_match_ptid (QUEUE (notif_event_p) *q,
 177                           QUEUE_ITER (notif_event_p) *iter,
 178                           struct notif_event *event,
 179                           void *data)
 180 {
 181   ptid_t filter_ptid = *(ptid_t *) data;
 182   struct vstop_notif *vstop_event = (struct vstop_notif *) event;
 183
 184   if (ptid_match (vstop_event->ptid, filter_ptid))
 185     {
 186       if (q->free_func != NULL)
 187         q->free_func (event);
 188
 189       QUEUE_remove_elem (notif_event_p, q, iter);
 190     }
 191
 192   return 1;
 193 }
 194
 195 /* See server.h.  */
 196
 197 void
 198 discard_queued_stop_replies (ptid_t ptid)
 199 {
 200   QUEUE_iterate (notif_event_p, notif_stop.queue,
 201                  remove_all_on_match_ptid, &ptid);
 202 }
 203
 204 static void
 205 vstop_notif_reply (struct notif_event *event, char *own_buf)
 206 {
 207   struct vstop_notif *vstop = (struct vstop_notif *) event;
 208
 209   prepare_resume_reply (own_buf, vstop->ptid, &vstop->status);
 210 }
 211
 212 /* QUEUE_iterate callback helper for in_queued_stop_replies.  */
 213
 214 static int
 215 in_queued_stop_replies_ptid (QUEUE (notif_event_p) *q,
 216                              QUEUE_ITER (notif_event_p) *iter,
 217                              struct notif_event *event,
 218                              void *data)
 219 {
 220   ptid_t filter_ptid = *(ptid_t *) data;
 221   struct vstop_notif *vstop_event = (struct vstop_notif *) event;
 222
 223   if (ptid_match (vstop_event->ptid, filter_ptid))
 224     return 0;
 225
 226   /* Don't resume fork children that GDB does not know about yet.  */
 227   if ((vstop_event->status.kind == TARGET_WAITKIND_FORKED
 228        || vstop_event->status.kind == TARGET_WAITKIND_VFORKED)
 229       && ptid_match (vstop_event->status.value.related_pid, filter_ptid))
 230     return 0;
 231
 232   return 1;
 233 }
 234
 235 /* See server.h.  */
 236
 237 int
 238 in_queued_stop_replies (ptid_t ptid)
 239 {
 240   return !QUEUE_iterate (notif_event_p, notif_stop.queue,
 241                          in_queued_stop_replies_ptid, &ptid);
 242 }
 243
 244 struct notif_server notif_stop =
 245 {
 246   "vStopped", "Stop", NULL, vstop_notif_reply,
 247 };
 248
 249 static int
 250 target_running (void)
 251 {
 252   return get_first_thread () != NULL;
 253 }
 254
 255 /* See common/common-inferior.h.  */
 256
 257 const char *
 258 get_exec_wrapper ()
 259 {
 260   return !wrapper_argv.empty () ? wrapper_argv.c_str () : NULL;
 261 }
 262
 263 /* See common/common-inferior.h.  */
 264
 265 char *
 266 get_exec_file (int err)
 267 {
 268   if (err && program_name == NULL)
 269     error (_("No executable file specified."));
 270
 271   return program_name;
 272 }
 273
 274 /* See server.h.  */
 275
 276 gdb_environ *
 277 get_environ ()
 278 {
 279   return &our_environ;
 280 }
 281
 282 static int
 283 attach_inferior (int pid)
 284 {
 285   /* myattach should return -1 if attaching is unsupported,
 286      0 if it succeeded, and call error() otherwise.  */
 287
 288   if (myattach (pid) != 0)
 289     return -1;
 290
 291   fprintf (stderr, "Attached; pid = %d\n", pid);
 292   fflush (stderr);
 293
 294   /* FIXME - It may be that we should get the SIGNAL_PID from the
 295      attach function, so that it can be the main thread instead of
 296      whichever we were told to attach to.  */
 297   signal_pid = pid;
 298
 299   if (!non_stop)
 300     {
 301       last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0);
 302
 303       /* GDB knows to ignore the first SIGSTOP after attaching to a running
 304          process using the "attach" command, but this is different; it's
 305          just using "target remote".  Pretend it's just starting up.  */
 306       if (last_status.kind == TARGET_WAITKIND_STOPPED
 307           && last_status.value.sig == GDB_SIGNAL_STOP)
 308         last_status.value.sig = GDB_SIGNAL_TRAP;
 309
 310       current_thread->last_resume_kind = resume_stop;
 311       current_thread->last_status = last_status;
 312     }
 313
 314   return 0;
 315 }
 316
 317 extern int remote_debug;
 318
 319 /* Decode a qXfer read request.  Return 0 if everything looks OK,
 320    or -1 otherwise.  */
 321
 322 static int
 323 decode_xfer_read (char *buf, CORE_ADDR *ofs, unsigned int *len)
 324 {
 325   /* After the read marker and annex, qXfer looks like a
 326      traditional 'm' packet.  */
 327   decode_m_packet (buf, ofs, len);
 328
 329   return 0;
 330 }
 331
 332 static int
 333 decode_xfer (char *buf, char **object, char **rw, char **annex, char **offset)
 334 {
 335   /* Extract and NUL-terminate the object.  */
 336   *object = buf;
 337   while (*buf && *buf != ':')
 338     buf++;
 339   if (*buf == '\0')
 340     return -1;
 341   *buf++ = 0;
 342
 343   /* Extract and NUL-terminate the read/write action.  */
 344   *rw = buf;
 345   while (*buf && *buf != ':')
 346     buf++;
 347   if (*buf == '\0')
 348     return -1;
 349   *buf++ = 0;
 350
 351   /* Extract and NUL-terminate the annex.  */
 352   *annex = buf;
 353   while (*buf && *buf != ':')
 354     buf++;
 355   if (*buf == '\0')
 356     return -1;
 357   *buf++ = 0;
 358
 359   *offset = buf;
 360   return 0;
 361 }
 362
 363 /* Write the response to a successful qXfer read.  Returns the
 364    length of the (binary) data stored in BUF, corresponding
 365    to as much of DATA/LEN as we could fit.  IS_MORE controls
 366    the first character of the response.  */
 367 static int
 368 write_qxfer_response (char *buf, const gdb_byte *data, int len, int is_more)
 369 {
 370   int out_len;
 371
 372   if (is_more)
 373     buf[0] = 'm';
 374   else
 375     buf[0] = 'l';
 376
 377   return remote_escape_output (data, len, 1, (unsigned char *) buf + 1,
 378                                &out_len, PBUFSIZ - 2) + 1;
 379 }
 380
 381 /* Handle btrace enabling in BTS format.  */
 382
 383 static const char *
 384 handle_btrace_enable_bts (struct thread_info *thread)
 385 {
 386   if (thread->btrace != NULL)
 387     return "E.Btrace already enabled.";
 388
 389   current_btrace_conf.format = BTRACE_FORMAT_BTS;
 390   thread->btrace = target_enable_btrace (thread->id, &current_btrace_conf);
 391   if (thread->btrace == NULL)
 392     return "E.Could not enable btrace.";
 393
 394   return NULL;
 395 }
 396
 397 /* Handle btrace enabling in Intel Processor Trace format.  */
 398
 399 static const char *
 400 handle_btrace_enable_pt (struct thread_info *thread)
 401 {
 402   if (thread->btrace != NULL)
 403     return "E.Btrace already enabled.";
 404
 405   current_btrace_conf.format = BTRACE_FORMAT_PT;
 406   thread->btrace = target_enable_btrace (thread->id, &current_btrace_conf);
 407   if (thread->btrace == NULL)
 408     return "E.Could not enable btrace.";
 409
 410   return NULL;
 411 }
 412
 413 /* Handle btrace disabling.  */
 414
 415 static const char *
 416 handle_btrace_disable (struct thread_info *thread)
 417 {
 418
 419   if (thread->btrace == NULL)
 420     return "E.Branch tracing not enabled.";
 421
 422   if (target_disable_btrace (thread->btrace) != 0)
 423     return "E.Could not disable branch tracing.";
 424
 425   thread->btrace = NULL;
 426   return NULL;
 427 }
 428
 429 /* Handle the "Qbtrace" packet.  */
 430
 431 static int
 432 handle_btrace_general_set (char *own_buf)
 433 {
 434   struct thread_info *thread;
 435   const char *err;
 436   char *op;
 437
 438   if (!startswith (own_buf, "Qbtrace:"))
 439     return 0;
 440
 441   op = own_buf + strlen ("Qbtrace:");
 442
 443   if (ptid_equal (general_thread, null_ptid)
 444       || ptid_equal (general_thread, minus_one_ptid))
 445     {
 446       strcpy (own_buf, "E.Must select a single thread.");
 447       return -1;
 448     }
 449
 450   thread = find_thread_ptid (general_thread);
 451   if (thread == NULL)
 452     {
 453       strcpy (own_buf, "E.No such thread.");
 454       return -1;
 455     }
 456
 457   err = NULL;
 458
 459   if (strcmp (op, "bts") == 0)
 460     err = handle_btrace_enable_bts (thread);
 461   else if (strcmp (op, "pt") == 0)
 462     err = handle_btrace_enable_pt (thread);
 463   else if (strcmp (op, "off") == 0)
 464     err = handle_btrace_disable (thread);
 465   else
 466     err = "E.Bad Qbtrace operation. Use bts, pt, or off.";
 467
 468   if (err != 0)
 469     strcpy (own_buf, err);
 470   else
 471     write_ok (own_buf);
 472
 473   return 1;
 474 }
 475
 476 /* Handle the "Qbtrace-conf" packet.  */
 477
 478 static int
 479 handle_btrace_conf_general_set (char *own_buf)
 480 {
 481   struct thread_info *thread;
 482   char *op;
 483
 484   if (!startswith (own_buf, "Qbtrace-conf:"))
 485     return 0;
 486
 487   op = own_buf + strlen ("Qbtrace-conf:");
 488
 489   if (ptid_equal (general_thread, null_ptid)
 490       || ptid_equal (general_thread, minus_one_ptid))
 491     {
 492       strcpy (own_buf, "E.Must select a single thread.");
 493       return -1;
 494     }
 495
 496   thread = find_thread_ptid (general_thread);
 497   if (thread == NULL)
 498     {
 499       strcpy (own_buf, "E.No such thread.");
 500       return -1;
 501     }
 502
 503   if (startswith (op, "bts:size="))
 504     {
 505       unsigned long size;
 506       char *endp = NULL;
 507
 508       errno = 0;
 509       size = strtoul (op + strlen ("bts:size="), &endp, 16);
 510       if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX)
 511         {
 512           strcpy (own_buf, "E.Bad size value.");
 513           return -1;
 514         }
 515
 516       current_btrace_conf.bts.size = (unsigned int) size;
 517     }
 518   else if (strncmp (op, "pt:size=", strlen ("pt:size=")) == 0)
 519     {
 520       unsigned long size;
 521       char *endp = NULL;
 522
 523       errno = 0;
 524       size = strtoul (op + strlen ("pt:size="), &endp, 16);
 525       if (endp == NULL || *endp != 0 || errno != 0 || size > UINT_MAX)
 526         {
 527           strcpy (own_buf, "E.Bad size value.");
 528           return -1;
 529         }
 530
 531       current_btrace_conf.pt.size = (unsigned int) size;
 532     }
 533   else
 534     {
 535       strcpy (own_buf, "E.Bad Qbtrace configuration option.");
 536       return -1;
 537     }
 538
 539   write_ok (own_buf);
 540   return 1;
 541 }
 542
 543 /* Handle all of the extended 'Q' packets.  */
 544
 545 static void
 546 handle_general_set (char *own_buf)
 547 {
 548   if (startswith (own_buf, "QPassSignals:"))
 549     {
 550       int numsigs = (int) GDB_SIGNAL_LAST, i;
 551       const char *p = own_buf + strlen ("QPassSignals:");
 552       CORE_ADDR cursig;
 553
 554       p = decode_address_to_semicolon (&cursig, p);
 555       for (i = 0; i < numsigs; i++)
 556         {
 557           if (i == cursig)
 558             {
 559               pass_signals[i] = 1;
 560               if (*p == '\0')
 561                 /* Keep looping, to clear the remaining signals.  */
 562                 cursig = -1;
 563               else
 564                 p = decode_address_to_semicolon (&cursig, p);
 565             }
 566           else
 567             pass_signals[i] = 0;
 568         }
 569       strcpy (own_buf, "OK");
 570       return;
 571     }
 572
 573   if (startswith (own_buf, "QProgramSignals:"))
 574     {
 575       int numsigs = (int) GDB_SIGNAL_LAST, i;
 576       const char *p = own_buf + strlen ("QProgramSignals:");
 577       CORE_ADDR cursig;
 578
 579       program_signals_p = 1;
 580
 581       p = decode_address_to_semicolon (&cursig, p);
 582       for (i = 0; i < numsigs; i++)
 583         {
 584           if (i == cursig)
 585             {
 586               program_signals[i] = 1;
 587               if (*p == '\0')
 588                 /* Keep looping, to clear the remaining signals.  */
 589                 cursig = -1;
 590               else
 591                 p = decode_address_to_semicolon (&cursig, p);
 592             }
 593           else
 594             program_signals[i] = 0;
 595         }
 596       strcpy (own_buf, "OK");
 597       return;
 598     }
 599
 600   if (startswith (own_buf, "QCatchSyscalls:"))
 601     {
 602       const char *p = own_buf + sizeof ("QCatchSyscalls:") - 1;
 603       int enabled = -1;
 604       CORE_ADDR sysno;
 605       struct process_info *process;
 606
 607       if (!target_running () || !target_supports_catch_syscall ())
 608         {
 609           write_enn (own_buf);
 610           return;
 611         }
 612
 613       if (strcmp (p, "0") == 0)
 614         enabled = 0;
 615       else if (p[0] == '1' && (p[1] == ';' || p[1] == '\0'))
 616         enabled = 1;
 617       else
 618         {
 619           fprintf (stderr, "Unknown catch-syscalls mode requested: %s\n",
 620                    own_buf);
 621           write_enn (own_buf);
 622           return;
 623         }
 624
 625       process = current_process ();
 626       process->syscalls_to_catch.clear ();
 627
 628       if (enabled)
 629         {
 630           p += 1;
 631           if (*p == ';')
 632             {
 633               p += 1;
 634               while (*p != '\0')
 635                 {
 636                   p = decode_address_to_semicolon (&sysno, p);
 637                   process->syscalls_to_catch.push_back (sysno);
 638                 }
 639             }
 640           else
 641             process->syscalls_to_catch.push_back (ANY_SYSCALL);
 642         }
 643
 644       write_ok (own_buf);
 645       return;
 646     }
 647
 648   if (strcmp (own_buf, "QEnvironmentReset") == 0)
 649     {
 650       our_environ = gdb_environ::from_host_environ ();
 651
 652       write_ok (own_buf);
 653       return;
 654     }
 655
 656   if (startswith (own_buf, "QEnvironmentHexEncoded:"))
 657     {
 658       const char *p = own_buf + sizeof ("QEnvironmentHexEncoded:") - 1;
 659       /* The final form of the environment variable.  FINAL_VAR will
 660          hold the 'VAR=VALUE' format.  */
 661       std::string final_var = hex2str (p);
 662       std::string var_name, var_value;
 663
 664       if (remote_debug)
 665         {
 666           debug_printf (_("[QEnvironmentHexEncoded received '%s']\n"), p);
 667           debug_printf (_("[Environment variable to be set: '%s']\n"),
 668                         final_var.c_str ());
 669           debug_flush ();
 670         }
 671
 672       size_t pos = final_var.find ('=');
 673       if (pos == std::string::npos)
 674         {
 675           warning (_("Unexpected format for environment variable: '%s'"),
 676                    final_var.c_str ());
 677           write_enn (own_buf);
 678           return;
 679         }
 680
 681       var_name = final_var.substr (0, pos);
 682       var_value = final_var.substr (pos + 1, std::string::npos);
 683
 684       our_environ.set (var_name.c_str (), var_value.c_str ());
 685
 686       write_ok (own_buf);
 687       return;
 688     }
 689
 690   if (startswith (own_buf, "QEnvironmentUnset:"))
 691     {
 692       const char *p = own_buf + sizeof ("QEnvironmentUnset:") - 1;
 693       std::string varname = hex2str (p);
 694
 695       if (remote_debug)
 696         {
 697           debug_printf (_("[QEnvironmentUnset received '%s']\n"), p);
 698           debug_printf (_("[Environment variable to be unset: '%s']\n"),
 699                         varname.c_str ());
 700           debug_flush ();
 701         }
 702
 703       our_environ.unset (varname.c_str ());
 704
 705       write_ok (own_buf);
 706       return;
 707     }
 708
 709   if (strcmp (own_buf, "QStartNoAckMode") == 0)
 710     {
 711       if (remote_debug)
 712         {
 713           debug_printf ("[noack mode enabled]\n");
 714           debug_flush ();
 715         }
 716
 717       noack_mode = 1;
 718       write_ok (own_buf);
 719       return;
 720     }
 721
 722   if (startswith (own_buf, "QNonStop:"))
 723     {
 724       char *mode = own_buf + 9;
 725       int req = -1;
 726       const char *req_str;
 727
 728       if (strcmp (mode, "0") == 0)
 729         req = 0;
 730       else if (strcmp (mode, "1") == 0)
 731         req = 1;
 732       else
 733         {
 734           /* We don't know what this mode is, so complain to
 735              GDB.  */
 736           fprintf (stderr, "Unknown non-stop mode requested: %s\n",
 737                    own_buf);
 738           write_enn (own_buf);
 739           return;
 740         }
 741
 742       req_str = req ? "non-stop" : "all-stop";
 743       if (start_non_stop (req) != 0)
 744         {
 745           fprintf (stderr, "Setting %s mode failed\n", req_str);
 746           write_enn (own_buf);
 747           return;
 748         }
 749
 750       non_stop = req;
 751
 752       if (remote_debug)
 753         debug_printf ("[%s mode enabled]\n", req_str);
 754
 755       write_ok (own_buf);
 756       return;
 757     }
 758
 759   if (startswith (own_buf, "QDisableRandomization:"))
 760     {
 761       char *packet = own_buf + strlen ("QDisableRandomization:");
 762       ULONGEST setting;
 763
 764       unpack_varlen_hex (packet, &setting);
 765       disable_randomization = setting;
 766
 767       if (remote_debug)
 768         {
 769           debug_printf (disable_randomization
 770                         ? "[address space randomization disabled]\n"
 771                         : "[address space randomization enabled]\n");
 772         }
 773
 774       write_ok (own_buf);
 775       return;
 776     }
 777
 778   if (target_supports_tracepoints ()
 779       && handle_tracepoint_general_set (own_buf))
 780     return;
 781
 782   if (startswith (own_buf, "QAgent:"))
 783     {
 784       char *mode = own_buf + strlen ("QAgent:");
 785       int req = 0;
 786
 787       if (strcmp (mode, "0") == 0)
 788         req = 0;
 789       else if (strcmp (mode, "1") == 0)
 790         req = 1;
 791       else
 792         {
 793           /* We don't know what this value is, so complain to GDB.  */
 794           sprintf (own_buf, "E.Unknown QAgent value");
 795           return;
 796         }
 797
 798       /* Update the flag.  */
 799       use_agent = req;
 800       if (remote_debug)
 801         debug_printf ("[%s agent]\n", req ? "Enable" : "Disable");
 802       write_ok (own_buf);
 803       return;
 804     }
 805
 806   if (handle_btrace_general_set (own_buf))
 807     return;
 808
 809   if (handle_btrace_conf_general_set (own_buf))
 810     return;
 811
 812   if (startswith (own_buf, "QThreadEvents:"))
 813     {
 814       char *mode = own_buf + strlen ("QThreadEvents:");
 815       enum tribool req = TRIBOOL_UNKNOWN;
 816
 817       if (strcmp (mode, "0") == 0)
 818         req = TRIBOOL_FALSE;
 819       else if (strcmp (mode, "1") == 0)
 820         req = TRIBOOL_TRUE;
 821       else
 822         {
 823           char *mode_copy = xstrdup (mode);
 824
 825           /* We don't know what this mode is, so complain to GDB.  */
 826           sprintf (own_buf, "E.Unknown thread-events mode requested: %s\n",
 827                    mode_copy);
 828           xfree (mode_copy);
 829           return;
 830         }
 831
 832       report_thread_events = (req == TRIBOOL_TRUE);
 833
 834       if (remote_debug)
 835         {
 836           const char *req_str = report_thread_events ? "enabled" : "disabled";
 837
 838           debug_printf ("[thread events are now %s]\n", req_str);
 839         }
 840
 841       write_ok (own_buf);
 842       return;
 843     }
 844
 845   if (startswith (own_buf, "QStartupWithShell:"))
 846     {
 847       const char *value = own_buf + strlen ("QStartupWithShell:");
 848
 849       if (strcmp (value, "1") == 0)
 850         startup_with_shell = true;
 851       else if (strcmp (value, "0") == 0)
 852         startup_with_shell = false;
 853       else
 854         {
 855           /* Unknown value.  */
 856           fprintf (stderr, "Unknown value to startup-with-shell: %s\n",
 857                    own_buf);
 858           write_enn (own_buf);
 859           return;
 860         }
 861
 862       if (remote_debug)
 863         debug_printf (_("[Inferior will %s started with shell]"),
 864                       startup_with_shell ? "be" : "not be");
 865
 866       write_ok (own_buf);
 867       return;
 868     }
 869
 870   if (startswith (own_buf, "QSetWorkingDir:"))
 871     {
 872       const char *p = own_buf + strlen ("QSetWorkingDir:");
 873
 874       if (*p != '\0')
 875         {
 876           std::string path = hex2str (p);
 877
 878           set_inferior_cwd (path.c_str ());
 879
 880           if (remote_debug)
 881             debug_printf (_("[Set the inferior's current directory to %s]\n"),
 882                           path.c_str ());
 883         }
 884       else
 885         {
 886           /* An empty argument means that we should clear out any
 887              previously set cwd for the inferior.  */
 888           set_inferior_cwd (NULL);
 889
 890           if (remote_debug)
 891             debug_printf (_("\
 892 [Unset the inferior's current directory; will use gdbserver's cwd]\n"));
 893         }
 894       write_ok (own_buf);
 895
 896       return;
 897     }
 898
 899   /* Otherwise we didn't know what packet it was.  Say we didn't
 900      understand it.  */
 901   own_buf[0] = 0;
 902 }
 903
 904 static const char *
 905 get_features_xml (const char *annex)
 906 {
 907   const struct target_desc *desc = current_target_desc ();
 908
 909   /* `desc->xmltarget' defines what to return when looking for the
 910      "target.xml" file.  Its contents can either be verbatim XML code
 911      (prefixed with a '@') or else the name of the actual XML file to
 912      be used in place of "target.xml".
 913
 914      This variable is set up from the auto-generated
 915      init_registers_... routine for the current target.  */
 916
 917   if (strcmp (annex, "target.xml") == 0)
 918     {
 919       const char *ret = tdesc_get_features_xml ((target_desc*) desc);
 920
 921       if (*ret == '@')
 922         return ret + 1;
 923       else
 924         annex = ret;
 925     }
 926
 927 #ifdef USE_XML
 928   {
 929     extern const char *const xml_builtin[][2];
 930     int i;
 931
 932     /* Look for the annex.  */
 933     for (i = 0; xml_builtin[i][0] != NULL; i++)
 934       if (strcmp (annex, xml_builtin[i][0]) == 0)
 935         break;
 936
 937     if (xml_builtin[i][0] != NULL)
 938       return xml_builtin[i][1];
 939   }
 940 #endif
 941
 942   return NULL;
 943 }
 944
 945 static void
 946 monitor_show_help (void)
 947 {
 948   monitor_output ("The following monitor commands are supported:\n");
 949   monitor_output ("  set debug <0|1>\n");
 950   monitor_output ("    Enable general debugging messages\n");
 951   monitor_output ("  set debug-hw-points <0|1>\n");
 952   monitor_output ("    Enable h/w breakpoint/watchpoint debugging messages\n");
 953   monitor_output ("  set remote-debug <0|1>\n");
 954   monitor_output ("    Enable remote protocol debugging messages\n");
 955   monitor_output ("  set debug-format option1[,option2,...]\n");
 956   monitor_output ("    Add additional information to debugging messages\n");
 957   monitor_output ("    Options: all, none");
 958   monitor_output (", timestamp");
 959   monitor_output ("\n");
 960   monitor_output ("  exit\n");
 961   monitor_output ("    Quit GDBserver\n");
 962 }
 963
 964 /* Read trace frame or inferior memory.  Returns the number of bytes
 965    actually read, zero when no further transfer is possible, and -1 on
 966    error.  Return of a positive value smaller than LEN does not
 967    indicate there's no more to be read, only the end of the transfer.
 968    E.g., when GDB reads memory from a traceframe, a first request may
 969    be served from a memory block that does not cover the whole request
 970    length.  A following request gets the rest served from either
 971    another block (of the same traceframe) or from the read-only
 972    regions.  */
 973
 974 static int
 975 gdb_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 976 {
 977   int res;
 978
 979   if (current_traceframe >= 0)
 980     {
 981       ULONGEST nbytes;
 982       ULONGEST length = len;
 983
 984       if (traceframe_read_mem (current_traceframe,
 985                                memaddr, myaddr, len, &nbytes))
 986         return -1;
 987       /* Data read from trace buffer, we're done.  */
 988       if (nbytes > 0)
 989         return nbytes;
 990       if (!in_readonly_region (memaddr, length))
 991         return -1;
 992       /* Otherwise we have a valid readonly case, fall through.  */
 993       /* (assume no half-trace half-real blocks for now) */
 994     }
 995
 996   res = prepare_to_access_memory ();
 997   if (res == 0)
 998     {
 999       if (set_desired_thread ())
1000         res = read_inferior_memory (memaddr, myaddr, len);
1001       else
1002         res = 1;
1003       done_accessing_memory ();
1004
1005       return res == 0 ? len : -1;
1006     }
1007   else
1008     return -1;
1009 }
1010
1011 /* Write trace frame or inferior memory.  Actually, writing to trace
1012    frames is forbidden.  */
1013
1014 static int
1015 gdb_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
1016 {
1017   if (current_traceframe >= 0)
1018     return EIO;
1019   else
1020     {
1021       int ret;
1022
1023       ret = prepare_to_access_memory ();
1024       if (ret == 0)
1025         {
1026           if (set_desired_thread ())
1027             ret = write_inferior_memory (memaddr, myaddr, len);
1028           else
1029             ret = EIO;
1030           done_accessing_memory ();
1031         }
1032       return ret;
1033     }
1034 }
1035
1036 /* Subroutine of handle_search_memory to simplify it.  */
1037
1038 static int
1039 handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len,
1040                         gdb_byte *pattern, unsigned pattern_len,
1041                         gdb_byte *search_buf,
1042                         unsigned chunk_size, unsigned search_buf_size,
1043                         CORE_ADDR *found_addrp)
1044 {
1045   /* Prime the search buffer.  */
1046
1047   if (gdb_read_memory (start_addr, search_buf, search_buf_size)
1048       != search_buf_size)
1049     {
1050       warning ("Unable to access %ld bytes of target "
1051                "memory at 0x%lx, halting search.",
1052                (long) search_buf_size, (long) start_addr);
1053       return -1;
1054     }
1055
1056   /* Perform the search.
1057
1058      The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1059      When we've scanned N bytes we copy the trailing bytes to the start and
1060      read in another N bytes.  */
1061
1062   while (search_space_len >= pattern_len)
1063     {
1064       gdb_byte *found_ptr;
1065       unsigned nr_search_bytes = (search_space_len < search_buf_size
1066                                   ? search_space_len
1067                                   : search_buf_size);
1068
1069       found_ptr = (gdb_byte *) memmem (search_buf, nr_search_bytes, pattern,
1070                                        pattern_len);
1071
1072       if (found_ptr != NULL)
1073         {
1074           CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
1075           *found_addrp = found_addr;
1076           return 1;
1077         }
1078
1079       /* Not found in this chunk, skip to next chunk.  */
1080
1081       /* Don't let search_space_len wrap here, it's unsigned.  */
1082       if (search_space_len >= chunk_size)
1083         search_space_len -= chunk_size;
1084       else
1085         search_space_len = 0;
1086
1087       if (search_space_len >= pattern_len)
1088         {
1089           unsigned keep_len = search_buf_size - chunk_size;
1090           CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
1091           int nr_to_read;
1092
1093           /* Copy the trailing part of the previous iteration to the front
1094              of the buffer for the next iteration.  */
1095           memcpy (search_buf, search_buf + chunk_size, keep_len);
1096
1097           nr_to_read = (search_space_len - keep_len < chunk_size
1098                         ? search_space_len - keep_len
1099                         : chunk_size);
1100
1101           if (gdb_read_memory (read_addr, search_buf + keep_len,
1102                                nr_to_read) != search_buf_size)
1103             {
1104               warning ("Unable to access %ld bytes of target memory "
1105                        "at 0x%lx, halting search.",
1106                        (long) nr_to_read, (long) read_addr);
1107               return -1;
1108             }
1109
1110           start_addr += chunk_size;
1111         }
1112     }
1113
1114   /* Not found.  */
1115
1116   return 0;
1117 }
1118
1119 /* Handle qSearch:memory packets.  */
1120
1121 static void
1122 handle_search_memory (char *own_buf, int packet_len)
1123 {
1124   CORE_ADDR start_addr;
1125   CORE_ADDR search_space_len;
1126   gdb_byte *pattern;
1127   unsigned int pattern_len;
1128   /* NOTE: also defined in find.c testcase.  */
1129 #define SEARCH_CHUNK_SIZE 16000
1130   const unsigned chunk_size = SEARCH_CHUNK_SIZE;
1131   /* Buffer to hold memory contents for searching.  */
1132   gdb_byte *search_buf;
1133   unsigned search_buf_size;
1134   int found;
1135   CORE_ADDR found_addr;
1136   int cmd_name_len = sizeof ("qSearch:memory:") - 1;
1137
1138   pattern = (gdb_byte *) malloc (packet_len);
1139   if (pattern == NULL)
1140     {
1141       error ("Unable to allocate memory to perform the search");
1142       strcpy (own_buf, "E00");
1143       return;
1144     }
1145   if (decode_search_memory_packet (own_buf + cmd_name_len,
1146                                    packet_len - cmd_name_len,
1147                                    &start_addr, &search_space_len,
1148                                    pattern, &pattern_len) < 0)
1149     {
1150       free (pattern);
1151       error ("Error in parsing qSearch:memory packet");
1152       strcpy (own_buf, "E00");
1153       return;
1154     }
1155
1156   search_buf_size = chunk_size + pattern_len - 1;
1157
1158   /* No point in trying to allocate a buffer larger than the search space.  */
1159   if (search_space_len < search_buf_size)
1160     search_buf_size = search_space_len;
1161
1162   search_buf = (gdb_byte *) malloc (search_buf_size);
1163   if (search_buf == NULL)
1164     {
1165       free (pattern);
1166       error ("Unable to allocate memory to perform the search");
1167       strcpy (own_buf, "E00");
1168       return;
1169     }
1170
1171   found = handle_search_memory_1 (start_addr, search_space_len,
1172                                   pattern, pattern_len,
1173                                   search_buf, chunk_size, search_buf_size,
1174                                   &found_addr);
1175
1176   if (found > 0)
1177     sprintf (own_buf, "1,%lx", (long) found_addr);
1178   else if (found == 0)
1179     strcpy (own_buf, "0");
1180   else
1181     strcpy (own_buf, "E00");
1182
1183   free (search_buf);
1184   free (pattern);
1185 }
1186
1187 /* Handle the "D" packet.  */
1188
1189 static void
1190 handle_detach (char *own_buf)
1191 {
1192   require_running_or_return (own_buf);
1193
1194   int pid;
1195
1196   if (multi_process)
1197     {
1198       /* skip 'D;' */
1199       pid = strtol (&own_buf[2], NULL, 16);
1200     }
1201   else
1202     pid = ptid_get_pid (current_ptid);
1203
1204   if ((tracing && disconnected_tracing) || any_persistent_commands ())
1205     {
1206       struct process_info *process = find_process_pid (pid);
1207
1208       if (process == NULL)
1209         {
1210           write_enn (own_buf);
1211           return;
1212         }
1213
1214       if (tracing && disconnected_tracing)
1215         fprintf (stderr,
1216                  "Disconnected tracing in effect, "
1217                  "leaving gdbserver attached to the process\n");
1218
1219       if (any_persistent_commands ())
1220         fprintf (stderr,
1221                  "Persistent commands are present, "
1222                  "leaving gdbserver attached to the process\n");
1223
1224       /* Make sure we're in non-stop/async mode, so we we can both
1225          wait for an async socket accept, and handle async target
1226          events simultaneously.  There's also no point either in
1227          having the target stop all threads, when we're going to
1228          pass signals down without informing GDB.  */
1229       if (!non_stop)
1230         {
1231           if (debug_threads)
1232             debug_printf ("Forcing non-stop mode\n");
1233
1234           non_stop = 1;
1235           start_non_stop (1);
1236         }
1237
1238       process->gdb_detached = 1;
1239
1240       /* Detaching implicitly resumes all threads.  */
1241       target_continue_no_signal (minus_one_ptid);
1242
1243       write_ok (own_buf);
1244       return;
1245     }
1246
1247   fprintf (stderr, "Detaching from process %d\n", pid);
1248   stop_tracing ();
1249   if (detach_inferior (pid) != 0)
1250     write_enn (own_buf);
1251   else
1252     {
1253       discard_queued_stop_replies (pid_to_ptid (pid));
1254       write_ok (own_buf);
1255
1256       if (extended_protocol || target_running ())
1257         {
1258           /* There is still at least one inferior remaining or
1259              we are in extended mode, so don't terminate gdbserver,
1260              and instead treat this like a normal program exit.  */
1261           last_status.kind = TARGET_WAITKIND_EXITED;
1262           last_status.value.integer = 0;
1263           last_ptid = pid_to_ptid (pid);
1264
1265           current_thread = NULL;
1266         }
1267       else
1268         {
1269           putpkt (own_buf);
1270           remote_close ();
1271
1272           /* If we are attached, then we can exit.  Otherwise, we
1273              need to hang around doing nothing, until the child is
1274              gone.  */
1275           join_inferior (pid);
1276           exit (0);
1277         }
1278     }
1279 }
1280
1281 /* Parse options to --debug-format= and "monitor set debug-format".
1282    ARG is the text after "--debug-format=" or "monitor set debug-format".
1283    IS_MONITOR is non-zero if we're invoked via "monitor set debug-format".
1284    This triggers calls to monitor_output.
1285    The result is NULL if all options were parsed ok, otherwise an error
1286    message which the caller must free.
1287
1288    N.B. These commands affect all debug format settings, they are not
1289    cumulative.  If a format is not specified, it is turned off.
1290    However, we don't go to extra trouble with things like
1291    "monitor set debug-format all,none,timestamp".
1292    Instead we just parse them one at a time, in order.
1293
1294    The syntax for "monitor set debug" we support here is not identical
1295    to gdb's "set debug foo on|off" because we also use this function to
1296    parse "--debug-format=foo,bar".  */
1297
1298 static char *
1299 parse_debug_format_options (const char *arg, int is_monitor)
1300 {
1301   VEC (char_ptr) *options;
1302   int ix;
1303   char *option;
1304
1305   /* First turn all debug format options off.  */
1306   debug_timestamp = 0;
1307
1308   /* First remove leading spaces, for "monitor set debug-format".  */
1309   while (isspace (*arg))
1310     ++arg;
1311
1312   options = delim_string_to_char_ptr_vec (arg, ',');
1313
1314   for (ix = 0; VEC_iterate (char_ptr, options, ix, option); ++ix)
1315     {
1316       if (strcmp (option, "all") == 0)
1317         {
1318           debug_timestamp = 1;
1319           if (is_monitor)
1320             monitor_output ("All extra debug format options enabled.\n");
1321         }
1322       else if (strcmp (option, "none") == 0)
1323         {
1324           debug_timestamp = 0;
1325           if (is_monitor)
1326             monitor_output ("All extra debug format options disabled.\n");
1327         }
1328       else if (strcmp (option, "timestamp") == 0)
1329         {
1330           debug_timestamp = 1;
1331           if (is_monitor)
1332             monitor_output ("Timestamps will be added to debug output.\n");
1333         }
1334       else if (*option == '\0')
1335         {
1336           /* An empty option, e.g., "--debug-format=foo,,bar", is ignored.  */
1337           continue;
1338         }
1339       else
1340         {
1341           char *msg = xstrprintf ("Unknown debug-format argument: \"%s\"\n",
1342                                   option);
1343
1344           free_char_ptr_vec (options);
1345           return msg;
1346         }
1347     }
1348
1349   free_char_ptr_vec (options);
1350   return NULL;
1351 }
1352
1353 /* Handle monitor commands not handled by target-specific handlers.  */
1354
1355 static void
1356 handle_monitor_command (char *mon, char *own_buf)
1357 {
1358   if (strcmp (mon, "set debug 1") == 0)
1359     {
1360       debug_threads = 1;
1361       monitor_output ("Debug output enabled.\n");
1362     }
1363   else if (strcmp (mon, "set debug 0") == 0)
1364     {
1365       debug_threads = 0;
1366       monitor_output ("Debug output disabled.\n");
1367     }
1368   else if (strcmp (mon, "set debug-hw-points 1") == 0)
1369     {
1370       show_debug_regs = 1;
1371       monitor_output ("H/W point debugging output enabled.\n");
1372     }
1373   else if (strcmp (mon, "set debug-hw-points 0") == 0)
1374     {
1375       show_debug_regs = 0;
1376       monitor_output ("H/W point debugging output disabled.\n");
1377     }
1378   else if (strcmp (mon, "set remote-debug 1") == 0)
1379     {
1380       remote_debug = 1;
1381       monitor_output ("Protocol debug output enabled.\n");
1382     }
1383   else if (strcmp (mon, "set remote-debug 0") == 0)
1384     {
1385       remote_debug = 0;
1386       monitor_output ("Protocol debug output disabled.\n");
1387     }
1388   else if (startswith (mon, "set debug-format "))
1389     {
1390       char *error_msg
1391         = parse_debug_format_options (mon + sizeof ("set debug-format ") - 1,
1392                                       1);
1393
1394       if (error_msg != NULL)
1395         {
1396           monitor_output (error_msg);
1397           monitor_show_help ();
1398           write_enn (own_buf);
1399           xfree (error_msg);
1400         }
1401     }
1402   else if (strcmp (mon, "help") == 0)
1403     monitor_show_help ();
1404   else if (strcmp (mon, "exit") == 0)
1405     exit_requested = 1;
1406   else
1407     {
1408       monitor_output ("Unknown monitor command.\n\n");
1409       monitor_show_help ();
1410       write_enn (own_buf);
1411     }
1412 }
1413
1414 /* Associates a callback with each supported qXfer'able object.  */
1415
1416 struct qxfer
1417 {
1418   /* The object this handler handles.  */
1419   const char *object;
1420
1421   /* Request that the target transfer up to LEN 8-bit bytes of the
1422      target's OBJECT.  The OFFSET, for a seekable object, specifies
1423      the starting point.  The ANNEX can be used to provide additional
1424      data-specific information to the target.
1425
1426      Return the number of bytes actually transfered, zero when no
1427      further transfer is possible, -1 on error, -2 when the transfer
1428      is not supported, and -3 on a verbose error message that should
1429      be preserved.  Return of a positive value smaller than LEN does
1430      not indicate the end of the object, only the end of the transfer.
1431
1432      One, and only one, of readbuf or writebuf must be non-NULL.  */
1433   int (*xfer) (const char *annex,
1434                gdb_byte *readbuf, const gdb_byte *writebuf,
1435                ULONGEST offset, LONGEST len);
1436 };
1437
1438 /* Handle qXfer:auxv:read.  */
1439
1440 static int
1441 handle_qxfer_auxv (const char *annex,
1442                    gdb_byte *readbuf, const gdb_byte *writebuf,
1443                    ULONGEST offset, LONGEST len)
1444 {
1445   if (the_target->read_auxv == NULL || writebuf != NULL)
1446     return -2;
1447
1448   if (annex[0] != '\0' || current_thread == NULL)
1449     return -1;
1450
1451   return (*the_target->read_auxv) (offset, readbuf, len);
1452 }
1453
1454 /* Handle qXfer:exec-file:read.  */
1455
1456 static int
1457 handle_qxfer_exec_file (const char *annex,
1458                         gdb_byte *readbuf, const gdb_byte *writebuf,
1459                         ULONGEST offset, LONGEST len)
1460 {
1461   char *file;
1462   ULONGEST pid;
1463   int total_len;
1464
1465   if (the_target->pid_to_exec_file == NULL || writebuf != NULL)
1466     return -2;
1467
1468   if (annex[0] == '\0')
1469     {
1470       if (current_thread == NULL)
1471         return -1;
1472
1473       pid = pid_of (current_thread);
1474     }
1475   else
1476     {
1477       annex = unpack_varlen_hex (annex, &pid);
1478       if (annex[0] != '\0')
1479         return -1;
1480     }
1481
1482   if (pid <= 0)
1483     return -1;
1484
1485   file = (*the_target->pid_to_exec_file) (pid);
1486   if (file == NULL)
1487     return -1;
1488
1489   total_len = strlen (file);
1490
1491   if (offset > total_len)
1492     return -1;
1493
1494   if (offset + len > total_len)
1495     len = total_len - offset;
1496
1497   memcpy (readbuf, file + offset, len);
1498   return len;
1499 }
1500
1501 /* Handle qXfer:features:read.  */
1502
1503 static int
1504 handle_qxfer_features (const char *annex,
1505                        gdb_byte *readbuf, const gdb_byte *writebuf,
1506                        ULONGEST offset, LONGEST len)
1507 {
1508   const char *document;
1509   size_t total_len;
1510
1511   if (writebuf != NULL)
1512     return -2;
1513
1514   if (!target_running ())
1515     return -1;
1516
1517   /* Grab the correct annex.  */
1518   document = get_features_xml (annex);
1519   if (document == NULL)
1520     return -1;
1521
1522   total_len = strlen (document);
1523
1524   if (offset > total_len)
1525     return -1;
1526
1527   if (offset + len > total_len)
1528     len = total_len - offset;
1529
1530   memcpy (readbuf, document + offset, len);
1531   return len;
1532 }
1533
1534 /* Handle qXfer:libraries:read.  */
1535
1536 static int
1537 handle_qxfer_libraries (const char *annex,
1538                         gdb_byte *readbuf, const gdb_byte *writebuf,
1539                         ULONGEST offset, LONGEST len)
1540 {
1541   if (writebuf != NULL)
1542     return -2;
1543
1544   if (annex[0] != '\0' || current_thread == NULL)
1545     return -1;
1546
1547   std::string document = "<library-list version=\"1.0\">\n";
1548
1549   for (const dll_info &dll : all_dlls)
1550     document += string_printf
1551       ("  <library name=\"%s\"><segment address=\"0x%lx\"/></library>\n",
1552        dll.name.c_str (), (long) dll.base_addr);
1553
1554   document += "</library-list>\n";
1555
1556   if (offset > document.length ())
1557     return -1;
1558
1559   if (offset + len > document.length ())
1560     len = document.length () - offset;
1561
1562   memcpy (readbuf, &document[offset], len);
1563
1564   return len;
1565 }
1566
1567 /* Handle qXfer:libraries-svr4:read.  */
1568
1569 static int
1570 handle_qxfer_libraries_svr4 (const char *annex,
1571                              gdb_byte *readbuf, const gdb_byte *writebuf,
1572                              ULONGEST offset, LONGEST len)
1573 {
1574   if (writebuf != NULL)
1575     return -2;
1576
1577   if (current_thread == NULL || the_target->qxfer_libraries_svr4 == NULL)
1578     return -1;
1579
1580   return the_target->qxfer_libraries_svr4 (annex, readbuf, writebuf, offset, len);
1581 }
1582
1583 /* Handle qXfer:osadata:read.  */
1584
1585 static int
1586 handle_qxfer_osdata (const char *annex,
1587                      gdb_byte *readbuf, const gdb_byte *writebuf,
1588                      ULONGEST offset, LONGEST len)
1589 {
1590   if (the_target->qxfer_osdata == NULL || writebuf != NULL)
1591     return -2;
1592
1593   return (*the_target->qxfer_osdata) (annex, readbuf, NULL, offset, len);
1594 }
1595
1596 /* Handle qXfer:siginfo:read and qXfer:siginfo:write.  */
1597
1598 static int
1599 handle_qxfer_siginfo (const char *annex,
1600                       gdb_byte *readbuf, const gdb_byte *writebuf,
1601                       ULONGEST offset, LONGEST len)
1602 {
1603   if (the_target->qxfer_siginfo == NULL)
1604     return -2;
1605
1606   if (annex[0] != '\0' || current_thread == NULL)
1607     return -1;
1608
1609   return (*the_target->qxfer_siginfo) (annex, readbuf, writebuf, offset, len);
1610 }
1611
1612 /* Handle qXfer:spu:read and qXfer:spu:write.  */
1613
1614 static int
1615 handle_qxfer_spu (const char *annex,
1616                   gdb_byte *readbuf, const gdb_byte *writebuf,
1617                   ULONGEST offset, LONGEST len)
1618 {
1619   if (the_target->qxfer_spu == NULL)
1620     return -2;
1621
1622   if (current_thread == NULL)
1623     return -1;
1624
1625   return (*the_target->qxfer_spu) (annex, readbuf, writebuf, offset, len);
1626 }
1627
1628 /* Handle qXfer:statictrace:read.  */
1629
1630 static int
1631 handle_qxfer_statictrace (const char *annex,
1632                           gdb_byte *readbuf, const gdb_byte *writebuf,
1633                           ULONGEST offset, LONGEST len)
1634 {
1635   ULONGEST nbytes;
1636
1637   if (writebuf != NULL)
1638     return -2;
1639
1640   if (annex[0] != '\0' || current_thread == NULL || current_traceframe == -1)
1641     return -1;
1642
1643   if (traceframe_read_sdata (current_traceframe, offset,
1644                              readbuf, len, &nbytes))
1645     return -1;
1646   return nbytes;
1647 }
1648
1649 /* Helper for handle_qxfer_threads_proper.
1650    Emit the XML to describe the thread of INF.  */
1651
1652 static void
1653 handle_qxfer_threads_worker (thread_info *thread, void *arg)
1654 {
1655   struct buffer *buffer = (struct buffer *) arg;
1656   ptid_t ptid = ptid_of (thread);
1657   char ptid_s[100];
1658   int core = target_core_of_thread (ptid);
1659   char core_s[21];
1660   const char *name = target_thread_name (ptid);
1661   int handle_len;
1662   gdb_byte *handle;
1663   bool handle_status = target_thread_handle (ptid, &handle, &handle_len);
1664
1665   write_ptid (ptid_s, ptid);
1666
1667   buffer_xml_printf (buffer, "<thread id=\"%s\"", ptid_s);
1668
1669   if (core != -1)
1670     {
1671       sprintf (core_s, "%d", core);
1672       buffer_xml_printf (buffer, " core=\"%s\"", core_s);
1673     }
1674
1675   if (name != NULL)
1676     buffer_xml_printf (buffer, " name=\"%s\"", name);
1677
1678   if (handle_status)
1679     {
1680       char *handle_s = (char *) alloca (handle_len * 2 + 1);
1681       bin2hex (handle, handle_s, handle_len);
1682       buffer_xml_printf (buffer, " handle=\"%s\"", handle_s);
1683     }
1684
1685   buffer_xml_printf (buffer, "/>\n");
1686 }
1687
1688 /* Helper for handle_qxfer_threads.  */
1689
1690 static void
1691 handle_qxfer_threads_proper (struct buffer *buffer)
1692 {
1693   buffer_grow_str (buffer, "<threads>\n");
1694
1695   for_each_inferior_with_data (&all_threads, handle_qxfer_threads_worker,
1696                                buffer);
1697
1698   buffer_grow_str0 (buffer, "</threads>\n");
1699 }
1700
1701 /* Handle qXfer:threads:read.  */
1702
1703 static int
1704 handle_qxfer_threads (const char *annex,
1705                       gdb_byte *readbuf, const gdb_byte *writebuf,
1706                       ULONGEST offset, LONGEST len)
1707 {
1708   static char *result = 0;
1709   static unsigned int result_length = 0;
1710
1711   if (writebuf != NULL)
1712     return -2;
1713
1714   if (annex[0] != '\0')
1715     return -1;
1716
1717   if (offset == 0)
1718     {
1719       struct buffer buffer;
1720       /* When asked for data at offset 0, generate everything and store into
1721          'result'.  Successive reads will be served off 'result'.  */
1722       if (result)
1723         free (result);
1724
1725       buffer_init (&buffer);
1726
1727       handle_qxfer_threads_proper (&buffer);
1728
1729       result = buffer_finish (&buffer);
1730       result_length = strlen (result);
1731       buffer_free (&buffer);
1732     }
1733
1734   if (offset >= result_length)
1735     {
1736       /* We're out of data.  */
1737       free (result);
1738       result = NULL;
1739       result_length = 0;
1740       return 0;
1741     }
1742
1743   if (len > result_length - offset)
1744     len = result_length - offset;
1745
1746   memcpy (readbuf, result + offset, len);
1747
1748   return len;
1749 }
1750
1751 /* Handle qXfer:traceframe-info:read.  */
1752
1753 static int
1754 handle_qxfer_traceframe_info (const char *annex,
1755                               gdb_byte *readbuf, const gdb_byte *writebuf,
1756                               ULONGEST offset, LONGEST len)
1757 {
1758   static char *result = 0;
1759   static unsigned int result_length = 0;
1760
1761   if (writebuf != NULL)
1762     return -2;
1763
1764   if (!target_running () || annex[0] != '\0' || current_traceframe == -1)
1765     return -1;
1766
1767   if (offset == 0)
1768     {
1769       struct buffer buffer;
1770
1771       /* When asked for data at offset 0, generate everything and
1772          store into 'result'.  Successive reads will be served off
1773          'result'.  */
1774       free (result);
1775
1776       buffer_init (&buffer);
1777
1778       traceframe_read_info (current_traceframe, &buffer);
1779
1780       result = buffer_finish (&buffer);
1781       result_length = strlen (result);
1782       buffer_free (&buffer);
1783     }
1784
1785   if (offset >= result_length)
1786     {
1787       /* We're out of data.  */
1788       free (result);
1789       result = NULL;
1790       result_length = 0;
1791       return 0;
1792     }
1793
1794   if (len > result_length - offset)
1795     len = result_length - offset;
1796
1797   memcpy (readbuf, result + offset, len);
1798   return len;
1799 }
1800
1801 /* Handle qXfer:fdpic:read.  */
1802
1803 static int
1804 handle_qxfer_fdpic (const char *annex, gdb_byte *readbuf,
1805                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1806 {
1807   if (the_target->read_loadmap == NULL)
1808     return -2;
1809
1810   if (current_thread == NULL)
1811     return -1;
1812
1813   return (*the_target->read_loadmap) (annex, offset, readbuf, len);
1814 }
1815
1816 /* Handle qXfer:btrace:read.  */
1817
1818 static int
1819 handle_qxfer_btrace (const char *annex,
1820                      gdb_byte *readbuf, const gdb_byte *writebuf,
1821                      ULONGEST offset, LONGEST len)
1822 {
1823   static struct buffer cache;
1824   struct thread_info *thread;
1825   enum btrace_read_type type;
1826   int result;
1827
1828   if (the_target->read_btrace == NULL || writebuf != NULL)
1829     return -2;
1830
1831   if (ptid_equal (general_thread, null_ptid)
1832       || ptid_equal (general_thread, minus_one_ptid))
1833     {
1834       strcpy (own_buf, "E.Must select a single thread.");
1835       return -3;
1836     }
1837
1838   thread = find_thread_ptid (general_thread);
1839   if (thread == NULL)
1840     {
1841       strcpy (own_buf, "E.No such thread.");
1842       return -3;
1843     }
1844
1845   if (thread->btrace == NULL)
1846     {
1847       strcpy (own_buf, "E.Btrace not enabled.");
1848       return -3;
1849     }
1850
1851   if (strcmp (annex, "all") == 0)
1852     type = BTRACE_READ_ALL;
1853   else if (strcmp (annex, "new") == 0)
1854     type = BTRACE_READ_NEW;
1855   else if (strcmp (annex, "delta") == 0)
1856     type = BTRACE_READ_DELTA;
1857   else
1858     {
1859       strcpy (own_buf, "E.Bad annex.");
1860       return -3;
1861     }
1862
1863   if (offset == 0)
1864     {
1865       buffer_free (&cache);
1866
1867       result = target_read_btrace (thread->btrace, &cache, type);
1868       if (result != 0)
1869         {
1870           memcpy (own_buf, cache.buffer, cache.used_size);
1871           return -3;
1872         }
1873     }
1874   else if (offset > cache.used_size)
1875     {
1876       buffer_free (&cache);
1877       return -3;
1878     }
1879
1880   if (len > cache.used_size - offset)
1881     len = cache.used_size - offset;
1882
1883   memcpy (readbuf, cache.buffer + offset, len);
1884
1885   return len;
1886 }
1887
1888 /* Handle qXfer:btrace-conf:read.  */
1889
1890 static int
1891 handle_qxfer_btrace_conf (const char *annex,
1892                           gdb_byte *readbuf, const gdb_byte *writebuf,
1893                           ULONGEST offset, LONGEST len)
1894 {
1895   static struct buffer cache;
1896   struct thread_info *thread;
1897   int result;
1898
1899   if (the_target->read_btrace_conf == NULL || writebuf != NULL)
1900     return -2;
1901
1902   if (annex[0] != '\0')
1903     return -1;
1904
1905   if (ptid_equal (general_thread, null_ptid)
1906       || ptid_equal (general_thread, minus_one_ptid))
1907     {
1908       strcpy (own_buf, "E.Must select a single thread.");
1909       return -3;
1910     }
1911
1912   thread = find_thread_ptid (general_thread);
1913   if (thread == NULL)
1914     {
1915       strcpy (own_buf, "E.No such thread.");
1916       return -3;
1917     }
1918
1919   if (thread->btrace == NULL)
1920     {
1921       strcpy (own_buf, "E.Btrace not enabled.");
1922       return -3;
1923     }
1924
1925   if (offset == 0)
1926     {
1927       buffer_free (&cache);
1928
1929       result = target_read_btrace_conf (thread->btrace, &cache);
1930       if (result != 0)
1931         {
1932           memcpy (own_buf, cache.buffer, cache.used_size);
1933           return -3;
1934         }
1935     }
1936   else if (offset > cache.used_size)
1937     {
1938       buffer_free (&cache);
1939       return -3;
1940     }
1941
1942   if (len > cache.used_size - offset)
1943     len = cache.used_size - offset;
1944
1945   memcpy (readbuf, cache.buffer + offset, len);
1946
1947   return len;
1948 }
1949
1950 static const struct qxfer qxfer_packets[] =
1951   {
1952     { "auxv", handle_qxfer_auxv },
1953     { "btrace", handle_qxfer_btrace },
1954     { "btrace-conf", handle_qxfer_btrace_conf },
1955     { "exec-file", handle_qxfer_exec_file},
1956     { "fdpic", handle_qxfer_fdpic},
1957     { "features", handle_qxfer_features },
1958     { "libraries", handle_qxfer_libraries },
1959     { "libraries-svr4", handle_qxfer_libraries_svr4 },
1960     { "osdata", handle_qxfer_osdata },
1961     { "siginfo", handle_qxfer_siginfo },
1962     { "spu", handle_qxfer_spu },
1963     { "statictrace", handle_qxfer_statictrace },
1964     { "threads", handle_qxfer_threads },
1965     { "traceframe-info", handle_qxfer_traceframe_info },
1966   };
1967
1968 static int
1969 handle_qxfer (char *own_buf, int packet_len, int *new_packet_len_p)
1970 {
1971   int i;
1972   char *object;
1973   char *rw;
1974   char *annex;
1975   char *offset;
1976
1977   if (!startswith (own_buf, "qXfer:"))
1978     return 0;
1979
1980   /* Grab the object, r/w and annex.  */
1981   if (decode_xfer (own_buf + 6, &object, &rw, &annex, &offset) < 0)
1982     {
1983       write_enn (own_buf);
1984       return 1;
1985     }
1986
1987   for (i = 0;
1988        i < sizeof (qxfer_packets) / sizeof (qxfer_packets[0]);
1989        i++)
1990     {
1991       const struct qxfer *q = &qxfer_packets[i];
1992
1993       if (strcmp (object, q->object) == 0)
1994         {
1995           if (strcmp (rw, "read") == 0)
1996             {
1997               unsigned char *data;
1998               int n;
1999               CORE_ADDR ofs;
2000               unsigned int len;
2001
2002               /* Grab the offset and length.  */
2003               if (decode_xfer_read (offset, &ofs, &len) < 0)
2004                 {
2005                   write_enn (own_buf);
2006                   return 1;
2007                 }
2008
2009               /* Read one extra byte, as an indicator of whether there is
2010                  more.  */
2011               if (len > PBUFSIZ - 2)
2012                 len = PBUFSIZ - 2;
2013               data = (unsigned char *) malloc (len + 1);
2014               if (data == NULL)
2015                 {
2016                   write_enn (own_buf);
2017                   return 1;
2018                 }
2019               n = (*q->xfer) (annex, data, NULL, ofs, len + 1);
2020               if (n == -2)
2021                 {
2022                   free (data);
2023                   return 0;
2024                 }
2025               else if (n == -3)
2026                 {
2027                   /* Preserve error message.  */
2028                 }
2029               else if (n < 0)
2030                 write_enn (own_buf);
2031               else if (n > len)
2032                 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
2033               else
2034                 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
2035
2036               free (data);
2037               return 1;
2038             }
2039           else if (strcmp (rw, "write") == 0)
2040             {
2041               int n;
2042               unsigned int len;
2043               CORE_ADDR ofs;
2044               unsigned char *data;
2045
2046               strcpy (own_buf, "E00");
2047               data = (unsigned char *) malloc (packet_len - (offset - own_buf));
2048               if (data == NULL)
2049                 {
2050                   write_enn (own_buf);
2051                   return 1;
2052                 }
2053               if (decode_xfer_write (offset, packet_len - (offset - own_buf),
2054                                      &ofs, &len, data) < 0)
2055                 {
2056                   free (data);
2057                   write_enn (own_buf);
2058                   return 1;
2059                 }
2060
2061               n = (*q->xfer) (annex, NULL, data, ofs, len);
2062               if (n == -2)
2063                 {
2064                   free (data);
2065                   return 0;
2066                 }
2067               else if (n == -3)
2068                 {
2069                   /* Preserve error message.  */
2070                 }
2071               else if (n < 0)
2072                 write_enn (own_buf);
2073               else
2074                 sprintf (own_buf, "%x", n);
2075
2076               free (data);
2077               return 1;
2078             }
2079
2080           return 0;
2081         }
2082     }
2083
2084   return 0;
2085 }
2086
2087 /* Compute 32 bit CRC from inferior memory.
2088
2089    On success, return 32 bit CRC.
2090    On failure, return (unsigned long long) -1.  */
2091
2092 static unsigned long long
2093 crc32 (CORE_ADDR base, int len, unsigned int crc)
2094 {
2095   while (len--)
2096     {
2097       unsigned char byte = 0;
2098
2099       /* Return failure if memory read fails.  */
2100       if (read_inferior_memory (base, &byte, 1) != 0)
2101         return (unsigned long long) -1;
2102
2103       crc = xcrc32 (&byte, 1, crc);
2104       base++;
2105     }
2106   return (unsigned long long) crc;
2107 }
2108
2109 /* Add supported btrace packets to BUF.  */
2110
2111 static void
2112 supported_btrace_packets (char *buf)
2113 {
2114   int btrace_supported = 0;
2115
2116   if (target_supports_btrace (BTRACE_FORMAT_BTS))
2117     {
2118       strcat (buf, ";Qbtrace:bts+");
2119       strcat (buf, ";Qbtrace-conf:bts:size+");
2120
2121       btrace_supported = 1;
2122     }
2123
2124   if (target_supports_btrace (BTRACE_FORMAT_PT))
2125     {
2126       strcat (buf, ";Qbtrace:pt+");
2127       strcat (buf, ";Qbtrace-conf:pt:size+");
2128
2129       btrace_supported = 1;
2130     }
2131
2132   if (!btrace_supported)
2133     return;
2134
2135   strcat (buf, ";Qbtrace:off+");
2136   strcat (buf, ";qXfer:btrace:read+");
2137   strcat (buf, ";qXfer:btrace-conf:read+");
2138 }
2139
2140 /* Handle all of the extended 'q' packets.  */
2141
2142 static void
2143 handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
2144 {
2145   static std::list<thread_info *>::const_iterator thread_iter;
2146
2147   /* Reply the current thread id.  */
2148   if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC)
2149     {
2150       ptid_t ptid;
2151       require_running_or_return (own_buf);
2152
2153       if (general_thread != null_ptid && general_thread != minus_one_ptid)
2154         ptid = general_thread;
2155       else
2156         {
2157           thread_iter = all_threads.begin ();
2158           ptid = (*thread_iter)->id;
2159         }
2160
2161       sprintf (own_buf, "QC");
2162       own_buf += 2;
2163       write_ptid (own_buf, ptid);
2164       return;
2165     }
2166
2167   if (strcmp ("qSymbol::", own_buf) == 0)
2168     {
2169       struct thread_info *save_thread = current_thread;
2170
2171       /* For qSymbol, GDB only changes the current thread if the
2172          previous current thread was of a different process.  So if
2173          the previous thread is gone, we need to pick another one of
2174          the same process.  This can happen e.g., if we followed an
2175          exec in a non-leader thread.  */
2176       if (current_thread == NULL)
2177         {
2178           current_thread
2179             = find_any_thread_of_pid (ptid_get_pid (general_thread));
2180
2181           /* Just in case, if we didn't find a thread, then bail out
2182              instead of crashing.  */
2183           if (current_thread == NULL)
2184             {
2185               write_enn (own_buf);
2186               current_thread = save_thread;
2187               return;
2188             }
2189         }
2190
2191       /* GDB is suggesting new symbols have been loaded.  This may
2192          mean a new shared library has been detected as loaded, so
2193          take the opportunity to check if breakpoints we think are
2194          inserted, still are.  Note that it isn't guaranteed that
2195          we'll see this when a shared library is loaded, and nor will
2196          we see this for unloads (although breakpoints in unloaded
2197          libraries shouldn't trigger), as GDB may not find symbols for
2198          the library at all.  We also re-validate breakpoints when we
2199          see a second GDB breakpoint for the same address, and or when
2200          we access breakpoint shadows.  */
2201       validate_breakpoints ();
2202
2203       if (target_supports_tracepoints ())
2204         tracepoint_look_up_symbols ();
2205
2206       if (current_thread != NULL && the_target->look_up_symbols != NULL)
2207         (*the_target->look_up_symbols) ();
2208
2209       current_thread = save_thread;
2210
2211       strcpy (own_buf, "OK");
2212       return;
2213     }
2214
2215   if (!disable_packet_qfThreadInfo)
2216     {
2217       if (strcmp ("qfThreadInfo", own_buf) == 0)
2218         {
2219           require_running_or_return (own_buf);
2220           thread_iter = all_threads.begin ();
2221
2222           *own_buf++ = 'm';
2223           ptid_t ptid = (*thread_iter)->id;
2224           write_ptid (own_buf, ptid);
2225           thread_iter++;
2226           return;
2227         }
2228
2229       if (strcmp ("qsThreadInfo", own_buf) == 0)
2230         {
2231           require_running_or_return (own_buf);
2232           if (thread_iter != all_threads.end ())
2233             {
2234               *own_buf++ = 'm';
2235               ptid_t ptid = (*thread_iter)->id;
2236               write_ptid (own_buf, ptid);
2237               thread_iter++;
2238               return;
2239             }
2240           else
2241             {
2242               sprintf (own_buf, "l");
2243               return;
2244             }
2245         }
2246     }
2247
2248   if (the_target->read_offsets != NULL
2249       && strcmp ("qOffsets", own_buf) == 0)
2250     {
2251       CORE_ADDR text, data;
2252
2253       require_running_or_return (own_buf);
2254       if (the_target->read_offsets (&text, &data))
2255         sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
2256                  (long)text, (long)data, (long)data);
2257       else
2258         write_enn (own_buf);
2259
2260       return;
2261     }
2262
2263   /* Protocol features query.  */
2264   if (startswith (own_buf, "qSupported")
2265       && (own_buf[10] == ':' || own_buf[10] == '\0'))
2266     {
2267       char *p = &own_buf[10];
2268       int gdb_supports_qRelocInsn = 0;
2269
2270       /* Process each feature being provided by GDB.  The first
2271          feature will follow a ':', and latter features will follow
2272          ';'.  */
2273       if (*p == ':')
2274         {
2275           char **qsupported = NULL;
2276           int count = 0;
2277           int unknown = 0;
2278           int i;
2279
2280           /* Two passes, to avoid nested strtok calls in
2281              target_process_qsupported.  */
2282           for (p = strtok (p + 1, ";");
2283                p != NULL;
2284                p = strtok (NULL, ";"))
2285             {
2286               count++;
2287               qsupported = XRESIZEVEC (char *, qsupported, count);
2288               qsupported[count - 1] = xstrdup (p);
2289             }
2290
2291           for (i = 0; i < count; i++)
2292             {
2293               p = qsupported[i];
2294               if (strcmp (p, "multiprocess+") == 0)
2295                 {
2296                   /* GDB supports and wants multi-process support if
2297                      possible.  */
2298                   if (target_supports_multi_process ())
2299                     multi_process = 1;
2300                 }
2301               else if (strcmp (p, "qRelocInsn+") == 0)
2302                 {
2303                   /* GDB supports relocate instruction requests.  */
2304                   gdb_supports_qRelocInsn = 1;
2305                 }
2306               else if (strcmp (p, "swbreak+") == 0)
2307                 {
2308                   /* GDB wants us to report whether a trap is caused
2309                      by a software breakpoint and for us to handle PC
2310                      adjustment if necessary on this target.  */
2311                   if (target_supports_stopped_by_sw_breakpoint ())
2312                     swbreak_feature = 1;
2313                 }
2314               else if (strcmp (p, "hwbreak+") == 0)
2315                 {
2316                   /* GDB wants us to report whether a trap is caused
2317                      by a hardware breakpoint.  */
2318                   if (target_supports_stopped_by_hw_breakpoint ())
2319                     hwbreak_feature = 1;
2320                 }
2321               else if (strcmp (p, "fork-events+") == 0)
2322                 {
2323                   /* GDB supports and wants fork events if possible.  */
2324                   if (target_supports_fork_events ())
2325                     report_fork_events = 1;
2326                 }
2327               else if (strcmp (p, "vfork-events+") == 0)
2328                 {
2329                   /* GDB supports and wants vfork events if possible.  */
2330                   if (target_supports_vfork_events ())
2331                     report_vfork_events = 1;
2332                 }
2333               else if (strcmp (p, "exec-events+") == 0)
2334                 {
2335                   /* GDB supports and wants exec events if possible.  */
2336                   if (target_supports_exec_events ())
2337                     report_exec_events = 1;
2338                 }
2339               else if (strcmp (p, "vContSupported+") == 0)
2340                 vCont_supported = 1;
2341               else if (strcmp (p, "QThreadEvents+") == 0)
2342                 ;
2343               else if (strcmp (p, "no-resumed+") == 0)
2344                 {
2345                   /* GDB supports and wants TARGET_WAITKIND_NO_RESUMED
2346                      events.  */
2347                   report_no_resumed = 1;
2348                 }
2349               else
2350                 {
2351                   /* Move the unknown features all together.  */
2352                   qsupported[i] = NULL;
2353                   qsupported[unknown] = p;
2354                   unknown++;
2355                 }
2356             }
2357
2358           /* Give the target backend a chance to process the unknown
2359              features.  */
2360           target_process_qsupported (qsupported, unknown);
2361
2362           for (i = 0; i < count; i++)
2363             free (qsupported[i]);
2364           free (qsupported);
2365         }
2366
2367       sprintf (own_buf,
2368                "PacketSize=%x;QPassSignals+;QProgramSignals+;"
2369                "QStartupWithShell+;QEnvironmentHexEncoded+;"
2370                "QEnvironmentReset+;QEnvironmentUnset+;"
2371                "QSetWorkingDir+",
2372                PBUFSIZ - 1);
2373
2374       if (target_supports_catch_syscall ())
2375         strcat (own_buf, ";QCatchSyscalls+");
2376
2377       if (the_target->qxfer_libraries_svr4 != NULL)
2378         strcat (own_buf, ";qXfer:libraries-svr4:read+"
2379                 ";augmented-libraries-svr4-read+");
2380       else
2381         {
2382           /* We do not have any hook to indicate whether the non-SVR4 target
2383              backend supports qXfer:libraries:read, so always report it.  */
2384           strcat (own_buf, ";qXfer:libraries:read+");
2385         }
2386
2387       if (the_target->read_auxv != NULL)
2388         strcat (own_buf, ";qXfer:auxv:read+");
2389
2390       if (the_target->qxfer_spu != NULL)
2391         strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
2392
2393       if (the_target->qxfer_siginfo != NULL)
2394         strcat (own_buf, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
2395
2396       if (the_target->read_loadmap != NULL)
2397         strcat (own_buf, ";qXfer:fdpic:read+");
2398
2399       /* We always report qXfer:features:read, as targets may
2400          install XML files on a subsequent call to arch_setup.
2401          If we reported to GDB on startup that we don't support
2402          qXfer:feature:read at all, we will never be re-queried.  */
2403       strcat (own_buf, ";qXfer:features:read+");
2404
2405       if (transport_is_reliable)
2406         strcat (own_buf, ";QStartNoAckMode+");
2407
2408       if (the_target->qxfer_osdata != NULL)
2409         strcat (own_buf, ";qXfer:osdata:read+");
2410
2411       if (target_supports_multi_process ())
2412         strcat (own_buf, ";multiprocess+");
2413
2414       if (target_supports_fork_events ())
2415         strcat (own_buf, ";fork-events+");
2416
2417       if (target_supports_vfork_events ())
2418         strcat (own_buf, ";vfork-events+");
2419
2420       if (target_supports_exec_events ())
2421         strcat (own_buf, ";exec-events+");
2422
2423       if (target_supports_non_stop ())
2424         strcat (own_buf, ";QNonStop+");
2425
2426       if (target_supports_disable_randomization ())
2427         strcat (own_buf, ";QDisableRandomization+");
2428
2429       strcat (own_buf, ";qXfer:threads:read+");
2430
2431       if (target_supports_tracepoints ())
2432         {
2433           strcat (own_buf, ";ConditionalTracepoints+");
2434           strcat (own_buf, ";TraceStateVariables+");
2435           strcat (own_buf, ";TracepointSource+");
2436           strcat (own_buf, ";DisconnectedTracing+");
2437           if (gdb_supports_qRelocInsn && target_supports_fast_tracepoints ())
2438             strcat (own_buf, ";FastTracepoints+");
2439           strcat (own_buf, ";StaticTracepoints+");
2440           strcat (own_buf, ";InstallInTrace+");
2441           strcat (own_buf, ";qXfer:statictrace:read+");
2442           strcat (own_buf, ";qXfer:traceframe-info:read+");
2443           strcat (own_buf, ";EnableDisableTracepoints+");
2444           strcat (own_buf, ";QTBuffer:size+");
2445           strcat (own_buf, ";tracenz+");
2446         }
2447
2448       if (target_supports_hardware_single_step ()
2449           || target_supports_software_single_step () )
2450         {
2451           strcat (own_buf, ";ConditionalBreakpoints+");
2452         }
2453       strcat (own_buf, ";BreakpointCommands+");
2454
2455       if (target_supports_agent ())
2456         strcat (own_buf, ";QAgent+");
2457
2458       supported_btrace_packets (own_buf);
2459
2460       if (target_supports_stopped_by_sw_breakpoint ())
2461         strcat (own_buf, ";swbreak+");
2462
2463       if (target_supports_stopped_by_hw_breakpoint ())
2464         strcat (own_buf, ";hwbreak+");
2465
2466       if (the_target->pid_to_exec_file != NULL)
2467         strcat (own_buf, ";qXfer:exec-file:read+");
2468
2469       strcat (own_buf, ";vContSupported+");
2470
2471       strcat (own_buf, ";QThreadEvents+");
2472
2473       strcat (own_buf, ";no-resumed+");
2474
2475       /* Reinitialize components as needed for the new connection.  */
2476       hostio_handle_new_gdb_connection ();
2477       target_handle_new_gdb_connection ();
2478
2479       return;
2480     }
2481
2482   /* Thread-local storage support.  */
2483   if (the_target->get_tls_address != NULL
2484       && startswith (own_buf, "qGetTLSAddr:"))
2485     {
2486       char *p = own_buf + 12;
2487       CORE_ADDR parts[2], address = 0;
2488       int i, err;
2489       ptid_t ptid = null_ptid;
2490
2491       require_running_or_return (own_buf);
2492
2493       for (i = 0; i < 3; i++)
2494         {
2495           char *p2;
2496           int len;
2497
2498           if (p == NULL)
2499             break;
2500
2501           p2 = strchr (p, ',');
2502           if (p2)
2503             {
2504               len = p2 - p;
2505               p2++;
2506             }
2507           else
2508             {
2509               len = strlen (p);
2510               p2 = NULL;
2511             }
2512
2513           if (i == 0)
2514             ptid = read_ptid (p, NULL);
2515           else
2516             decode_address (&parts[i - 1], p, len);
2517           p = p2;
2518         }
2519
2520       if (p != NULL || i < 3)
2521         err = 1;
2522       else
2523         {
2524           struct thread_info *thread = find_thread_ptid (ptid);
2525
2526           if (thread == NULL)
2527             err = 2;
2528           else
2529             err = the_target->get_tls_address (thread, parts[0], parts[1],
2530                                                &address);
2531         }
2532
2533       if (err == 0)
2534         {
2535           strcpy (own_buf, paddress(address));
2536           return;
2537         }
2538       else if (err > 0)
2539         {
2540           write_enn (own_buf);
2541           return;
2542         }
2543
2544       /* Otherwise, pretend we do not understand this packet.  */
2545     }
2546
2547   /* Windows OS Thread Information Block address support.  */
2548   if (the_target->get_tib_address != NULL
2549       && startswith (own_buf, "qGetTIBAddr:"))
2550     {
2551       const char *annex;
2552       int n;
2553       CORE_ADDR tlb;
2554       ptid_t ptid = read_ptid (own_buf + 12, &annex);
2555
2556       n = (*the_target->get_tib_address) (ptid, &tlb);
2557       if (n == 1)
2558         {
2559           strcpy (own_buf, paddress(tlb));
2560           return;
2561         }
2562       else if (n == 0)
2563         {
2564           write_enn (own_buf);
2565           return;
2566         }
2567       return;
2568     }
2569
2570   /* Handle "monitor" commands.  */
2571   if (startswith (own_buf, "qRcmd,"))
2572     {
2573       char *mon = (char *) malloc (PBUFSIZ);
2574       int len = strlen (own_buf + 6);
2575
2576       if (mon == NULL)
2577         {
2578           write_enn (own_buf);
2579           return;
2580         }
2581
2582       if ((len % 2) != 0
2583           || hex2bin (own_buf + 6, (gdb_byte *) mon, len / 2) != len / 2)
2584         {
2585           write_enn (own_buf);
2586           free (mon);
2587           return;
2588         }
2589       mon[len / 2] = '\0';
2590
2591       write_ok (own_buf);
2592
2593       if (the_target->handle_monitor_command == NULL
2594           || (*the_target->handle_monitor_command) (mon) == 0)
2595         /* Default processing.  */
2596         handle_monitor_command (mon, own_buf);
2597
2598       free (mon);
2599       return;
2600     }
2601
2602   if (startswith (own_buf, "qSearch:memory:"))
2603     {
2604       require_running_or_return (own_buf);
2605       handle_search_memory (own_buf, packet_len);
2606       return;
2607     }
2608
2609   if (strcmp (own_buf, "qAttached") == 0
2610       || startswith (own_buf, "qAttached:"))
2611     {
2612       struct process_info *process;
2613
2614       if (own_buf[sizeof ("qAttached") - 1])
2615         {
2616           int pid = strtoul (own_buf + sizeof ("qAttached:") - 1, NULL, 16);
2617           process = find_process_pid (pid);
2618         }
2619       else
2620         {
2621           require_running_or_return (own_buf);
2622           process = current_process ();
2623         }
2624
2625       if (process == NULL)
2626         {
2627           write_enn (own_buf);
2628           return;
2629         }
2630
2631       strcpy (own_buf, process->attached ? "1" : "0");
2632       return;
2633     }
2634
2635   if (startswith (own_buf, "qCRC:"))
2636     {
2637       /* CRC check (compare-section).  */
2638       const char *comma;
2639       ULONGEST base;
2640       int len;
2641       unsigned long long crc;
2642
2643       require_running_or_return (own_buf);
2644       comma = unpack_varlen_hex (own_buf + 5, &base);
2645       if (*comma++ != ',')
2646         {
2647           write_enn (own_buf);
2648           return;
2649         }
2650       len = strtoul (comma, NULL, 16);
2651       crc = crc32 (base, len, 0xffffffff);
2652       /* Check for memory failure.  */
2653       if (crc == (unsigned long long) -1)
2654         {
2655           write_enn (own_buf);
2656           return;
2657         }
2658       sprintf (own_buf, "C%lx", (unsigned long) crc);
2659       return;
2660     }
2661
2662   if (handle_qxfer (own_buf, packet_len, new_packet_len_p))
2663     return;
2664
2665   if (target_supports_tracepoints () && handle_tracepoint_query (own_buf))
2666     return;
2667
2668   /* Otherwise we didn't know what packet it was.  Say we didn't
2669      understand it.  */
2670   own_buf[0] = 0;
2671 }
2672
2673 static void gdb_wants_all_threads_stopped (void);
2674 static void resume (struct thread_resume *actions, size_t n);
2675
2676 /* The callback that is passed to visit_actioned_threads.  */
2677 typedef int (visit_actioned_threads_callback_ftype)
2678   (const struct thread_resume *, struct thread_info *);
2679
2680 /* Call CALLBACK for any thread to which ACTIONS applies to.  Returns
2681    true if CALLBACK returns true.  Returns false if no matching thread
2682    is found or CALLBACK results false.
2683    Note: This function is itself a callback for find_thread.  */
2684
2685 static bool
2686 visit_actioned_threads (thread_info *thread,
2687                         const struct thread_resume *actions,
2688                         size_t num_actions,
2689                         visit_actioned_threads_callback_ftype *callback)
2690 {
2691   for (size_t i = 0; i < num_actions; i++)
2692     {
2693       const struct thread_resume *action = &actions[i];
2694
2695       if (ptid_equal (action->thread, minus_one_ptid)
2696           || ptid_equal (action->thread, thread->id)
2697           || ((ptid_get_pid (action->thread)
2698                == thread->id.pid ())
2699               && ptid_get_lwp (action->thread) == -1))
2700         {
2701           if ((*callback) (action, thread))
2702             return true;
2703         }
2704     }
2705
2706   return false;
2707 }
2708
2709 /* Callback for visit_actioned_threads.  If the thread has a pending
2710    status to report, report it now.  */
2711
2712 static int
2713 handle_pending_status (const struct thread_resume *resumption,
2714                        struct thread_info *thread)
2715 {
2716   if (thread->status_pending_p)
2717     {
2718       thread->status_pending_p = 0;
2719
2720       last_status = thread->last_status;
2721       last_ptid = thread->id;
2722       prepare_resume_reply (own_buf, last_ptid, &last_status);
2723       return 1;
2724     }
2725   return 0;
2726 }
2727
2728 /* Parse vCont packets.  */
2729 static void
2730 handle_v_cont (char *own_buf)
2731 {
2732   const char *p;
2733   int n = 0, i = 0;
2734   struct thread_resume *resume_info;
2735   struct thread_resume default_action { null_ptid };
2736
2737   /* Count the number of semicolons in the packet.  There should be one
2738      for every action.  */
2739   p = &own_buf[5];
2740   while (p)
2741     {
2742       n++;
2743       p++;
2744       p = strchr (p, ';');
2745     }
2746
2747   resume_info = (struct thread_resume *) malloc (n * sizeof (resume_info[0]));
2748   if (resume_info == NULL)
2749     goto err;
2750
2751   p = &own_buf[5];
2752   while (*p)
2753     {
2754       p++;
2755
2756       memset (&resume_info[i], 0, sizeof resume_info[i]);
2757
2758       if (p[0] == 's' || p[0] == 'S')
2759         resume_info[i].kind = resume_step;
2760       else if (p[0] == 'r')
2761         resume_info[i].kind = resume_step;
2762       else if (p[0] == 'c' || p[0] == 'C')
2763         resume_info[i].kind = resume_continue;
2764       else if (p[0] == 't')
2765         resume_info[i].kind = resume_stop;
2766       else
2767         goto err;
2768
2769       if (p[0] == 'S' || p[0] == 'C')
2770         {
2771           char *q;
2772           int sig = strtol (p + 1, &q, 16);
2773           if (p == q)
2774             goto err;
2775           p = q;
2776
2777           if (!gdb_signal_to_host_p ((enum gdb_signal) sig))
2778             goto err;
2779           resume_info[i].sig = gdb_signal_to_host ((enum gdb_signal) sig);
2780         }
2781       else if (p[0] == 'r')
2782         {
2783           ULONGEST addr;
2784
2785           p = unpack_varlen_hex (p + 1, &addr);
2786           resume_info[i].step_range_start = addr;
2787
2788           if (*p != ',')
2789             goto err;
2790
2791           p = unpack_varlen_hex (p + 1, &addr);
2792           resume_info[i].step_range_end = addr;
2793         }
2794       else
2795         {
2796           p = p + 1;
2797         }
2798
2799       if (p[0] == 0)
2800         {
2801           resume_info[i].thread = minus_one_ptid;
2802           default_action = resume_info[i];
2803
2804           /* Note: we don't increment i here, we'll overwrite this entry
2805              the next time through.  */
2806         }
2807       else if (p[0] == ':')
2808         {
2809           const char *q;
2810           ptid_t ptid = read_ptid (p + 1, &q);
2811
2812           if (p == q)
2813             goto err;
2814           p = q;
2815           if (p[0] != ';' && p[0] != 0)
2816             goto err;
2817
2818           resume_info[i].thread = ptid;
2819
2820           i++;
2821         }
2822     }
2823
2824   if (i < n)
2825     resume_info[i] = default_action;
2826
2827   resume (resume_info, n);
2828   free (resume_info);
2829   return;
2830
2831 err:
2832   write_enn (own_buf);
2833   free (resume_info);
2834   return;
2835 }
2836
2837 /* Resume target with ACTIONS, an array of NUM_ACTIONS elements.  */
2838
2839 static void
2840 resume (struct thread_resume *actions, size_t num_actions)
2841 {
2842   if (!non_stop)
2843     {
2844       /* Check if among the threads that GDB wants actioned, there's
2845          one with a pending status to report.  If so, skip actually
2846          resuming/stopping and report the pending event
2847          immediately.  */
2848
2849       thread_info *thread_with_status = find_thread ([&] (thread_info *thread)
2850         {
2851           return visit_actioned_threads (thread, actions, num_actions,
2852                                          handle_pending_status);
2853         });
2854
2855       if (thread_with_status != NULL)
2856         return;
2857
2858       enable_async_io ();
2859     }
2860
2861   (*the_target->resume) (actions, num_actions);
2862
2863   if (non_stop)
2864     write_ok (own_buf);
2865   else
2866     {
2867       last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
2868
2869       if (last_status.kind == TARGET_WAITKIND_NO_RESUMED
2870           && !report_no_resumed)
2871         {
2872           /* The client does not support this stop reply.  At least
2873              return error.  */
2874           sprintf (own_buf, "E.No unwaited-for children left.");
2875           disable_async_io ();
2876           return;
2877         }
2878
2879       if (last_status.kind != TARGET_WAITKIND_EXITED
2880           && last_status.kind != TARGET_WAITKIND_SIGNALLED
2881           && last_status.kind != TARGET_WAITKIND_NO_RESUMED)
2882         current_thread->last_status = last_status;
2883
2884       /* From the client's perspective, all-stop mode always stops all
2885          threads implicitly (and the target backend has already done
2886          so by now).  Tag all threads as "want-stopped", so we don't
2887          resume them implicitly without the client telling us to.  */
2888       gdb_wants_all_threads_stopped ();
2889       prepare_resume_reply (own_buf, last_ptid, &last_status);
2890       disable_async_io ();
2891
2892       if (last_status.kind == TARGET_WAITKIND_EXITED
2893           || last_status.kind == TARGET_WAITKIND_SIGNALLED)
2894         target_mourn_inferior (last_ptid);
2895     }
2896 }
2897
2898 /* Attach to a new program.  Return 1 if successful, 0 if failure.  */
2899 static int
2900 handle_v_attach (char *own_buf)
2901 {
2902   int pid;
2903
2904   pid = strtol (own_buf + 8, NULL, 16);
2905   if (pid != 0 && attach_inferior (pid) == 0)
2906     {
2907       /* Don't report shared library events after attaching, even if
2908          some libraries are preloaded.  GDB will always poll the
2909          library list.  Avoids the "stopped by shared library event"
2910          notice on the GDB side.  */
2911       dlls_changed = 0;
2912
2913       if (non_stop)
2914         {
2915           /* In non-stop, we don't send a resume reply.  Stop events
2916              will follow up using the normal notification
2917              mechanism.  */
2918           write_ok (own_buf);
2919         }
2920       else
2921         prepare_resume_reply (own_buf, last_ptid, &last_status);
2922
2923       return 1;
2924     }
2925   else
2926     {
2927       write_enn (own_buf);
2928       return 0;
2929     }
2930 }
2931
2932 /* Run a new program.  Return 1 if successful, 0 if failure.  */
2933 static int
2934 handle_v_run (char *own_buf)
2935 {
2936   char *p, *next_p;
2937   std::vector<char *> new_argv;
2938   char *new_program_name = NULL;
2939   int i, new_argc;
2940
2941   new_argc = 0;
2942   for (p = own_buf + strlen ("vRun;"); p && *p; p = strchr (p, ';'))
2943     {
2944       p++;
2945       new_argc++;
2946     }
2947
2948   for (i = 0, p = own_buf + strlen ("vRun;"); *p; p = next_p, ++i)
2949     {
2950       next_p = strchr (p, ';');
2951       if (next_p == NULL)
2952         next_p = p + strlen (p);
2953
2954       if (i == 0 && p == next_p)
2955         {
2956           /* No program specified.  */
2957           new_program_name = NULL;
2958         }
2959       else if (p == next_p)
2960         {
2961           /* Empty argument.  */
2962           new_argv.push_back (xstrdup ("''"));
2963         }
2964       else
2965         {
2966           size_t len = (next_p - p) / 2;
2967           /* ARG is the unquoted argument received via the RSP.  */
2968           char *arg = (char *) xmalloc (len + 1);
2969           /* FULL_ARGS will contain the quoted version of ARG.  */
2970           char *full_arg = (char *) xmalloc ((len + 1) * 2);
2971           /* These are pointers used to navigate the strings above.  */
2972           char *tmp_arg = arg;
2973           char *tmp_full_arg = full_arg;
2974           int need_quote = 0;
2975
2976           hex2bin (p, (gdb_byte *) arg, len);
2977           arg[len] = '\0';
2978
2979           while (*tmp_arg != '\0')
2980             {
2981               switch (*tmp_arg)
2982                 {
2983                 case '\n':
2984                   /* Quote \n.  */
2985                   *tmp_full_arg = '\'';
2986                   ++tmp_full_arg;
2987                   need_quote = 1;
2988                   break;
2989
2990                 case '\'':
2991                   /* Quote single quote.  */
2992                   *tmp_full_arg = '\\';
2993                   ++tmp_full_arg;
2994                   break;
2995
2996                 default:
2997                   break;
2998                 }
2999
3000               *tmp_full_arg = *tmp_arg;
3001               ++tmp_full_arg;
3002               ++tmp_arg;
3003             }
3004
3005           if (need_quote)
3006             *tmp_full_arg++ = '\'';
3007
3008           /* Finish FULL_ARG and push it into the vector containing
3009              the argv.  */
3010           *tmp_full_arg = '\0';
3011           if (i == 0)
3012             new_program_name = full_arg;
3013           else
3014             new_argv.push_back (full_arg);
3015           xfree (arg);
3016         }
3017       if (*next_p)
3018         next_p++;
3019     }
3020   new_argv.push_back (NULL);
3021
3022   if (new_program_name == NULL)
3023     {
3024       /* GDB didn't specify a program to run.  Use the program from the
3025          last run with the new argument list.  */
3026       if (program_name == NULL)
3027         {
3028           write_enn (own_buf);
3029           free_vector_argv (new_argv);
3030           return 0;
3031         }
3032     }
3033   else
3034     {
3035       xfree (program_name);
3036       program_name = new_program_name;
3037     }
3038
3039   /* Free the old argv and install the new one.  */
3040   free_vector_argv (program_args);
3041   program_args = new_argv;
3042
3043   create_inferior (program_name, program_args);
3044
3045   if (last_status.kind == TARGET_WAITKIND_STOPPED)
3046     {
3047       prepare_resume_reply (own_buf, last_ptid, &last_status);
3048
3049       /* In non-stop, sending a resume reply doesn't set the general
3050          thread, but GDB assumes a vRun sets it (this is so GDB can
3051          query which is the main thread of the new inferior.  */
3052       if (non_stop)
3053         general_thread = last_ptid;
3054
3055       return 1;
3056     }
3057   else
3058     {
3059       write_enn (own_buf);
3060       return 0;
3061     }
3062 }
3063
3064 /* Kill process.  Return 1 if successful, 0 if failure.  */
3065 static int
3066 handle_v_kill (char *own_buf)
3067 {
3068   int pid;
3069   char *p = &own_buf[6];
3070   if (multi_process)
3071     pid = strtol (p, NULL, 16);
3072   else
3073     pid = signal_pid;
3074   if (pid != 0 && kill_inferior (pid) == 0)
3075     {
3076       last_status.kind = TARGET_WAITKIND_SIGNALLED;
3077       last_status.value.sig = GDB_SIGNAL_KILL;
3078       last_ptid = pid_to_ptid (pid);
3079       discard_queued_stop_replies (last_ptid);
3080       write_ok (own_buf);
3081       return 1;
3082     }
3083   else
3084     {
3085       write_enn (own_buf);
3086       return 0;
3087     }
3088 }
3089
3090 /* Handle all of the extended 'v' packets.  */
3091 void
3092 handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
3093 {
3094   if (!disable_packet_vCont)
3095     {
3096       if (strcmp (own_buf, "vCtrlC") == 0)
3097         {
3098           (*the_target->request_interrupt) ();
3099           write_ok (own_buf);
3100           return;
3101         }
3102
3103       if (startswith (own_buf, "vCont;"))
3104         {
3105           handle_v_cont (own_buf);
3106           return;
3107         }
3108
3109       if (startswith (own_buf, "vCont?"))
3110         {
3111           strcpy (own_buf, "vCont;c;C;t");
3112
3113           if (target_supports_hardware_single_step ()
3114               || target_supports_software_single_step ()
3115               || !vCont_supported)
3116             {
3117               /* If target supports single step either by hardware or by
3118                  software, add actions s and S to the list of supported
3119                  actions.  On the other hand, if GDB doesn't request the
3120                  supported vCont actions in qSupported packet, add s and
3121                  S to the list too.  */
3122               own_buf = own_buf + strlen (own_buf);
3123               strcpy (own_buf, ";s;S");
3124             }
3125
3126           if (target_supports_range_stepping ())
3127             {
3128               own_buf = own_buf + strlen (own_buf);
3129               strcpy (own_buf, ";r");
3130             }
3131           return;
3132         }
3133     }
3134
3135   if (startswith (own_buf, "vFile:")
3136       && handle_vFile (own_buf, packet_len, new_packet_len))
3137     return;
3138
3139   if (startswith (own_buf, "vAttach;"))
3140     {
3141       if ((!extended_protocol || !multi_process) && target_running ())
3142         {
3143           fprintf (stderr, "Already debugging a process\n");
3144           write_enn (own_buf);
3145           return;
3146         }
3147       handle_v_attach (own_buf);
3148       return;
3149     }
3150
3151   if (startswith (own_buf, "vRun;"))
3152     {
3153       if ((!extended_protocol || !multi_process) && target_running ())
3154         {
3155           fprintf (stderr, "Already debugging a process\n");
3156           write_enn (own_buf);
3157           return;
3158         }
3159       handle_v_run (own_buf);
3160       return;
3161     }
3162
3163   if (startswith (own_buf, "vKill;"))
3164     {
3165       if (!target_running ())
3166         {
3167           fprintf (stderr, "No process to kill\n");
3168           write_enn (own_buf);
3169           return;
3170         }
3171       handle_v_kill (own_buf);
3172       return;
3173     }
3174
3175   if (handle_notif_ack (own_buf, packet_len))
3176     return;
3177
3178   /* Otherwise we didn't know what packet it was.  Say we didn't
3179      understand it.  */
3180   own_buf[0] = 0;
3181   return;
3182 }
3183
3184 /* Resume thread and wait for another event.  In non-stop mode,
3185    don't really wait here, but return immediatelly to the event
3186    loop.  */
3187 static void
3188 myresume (char *own_buf, int step, int sig)
3189 {
3190   struct thread_resume resume_info[2];
3191   int n = 0;
3192   int valid_cont_thread;
3193
3194   valid_cont_thread = (!ptid_equal (cont_thread, null_ptid)
3195                          && !ptid_equal (cont_thread, minus_one_ptid));
3196
3197   if (step || sig || valid_cont_thread)
3198     {
3199       resume_info[0].thread = current_ptid;
3200       if (step)
3201         resume_info[0].kind = resume_step;
3202       else
3203         resume_info[0].kind = resume_continue;
3204       resume_info[0].sig = sig;
3205       n++;
3206     }
3207
3208   if (!valid_cont_thread)
3209     {
3210       resume_info[n].thread = minus_one_ptid;
3211       resume_info[n].kind = resume_continue;
3212       resume_info[n].sig = 0;
3213       n++;
3214     }
3215
3216   resume (resume_info, n);
3217 }
3218
3219 /* Callback for for_each_inferior.  Make a new stop reply for each
3220    stopped thread.  */
3221
3222 static void
3223 queue_stop_reply_callback (thread_info *thread)
3224 {
3225   /* For now, assume targets that don't have this callback also don't
3226      manage the thread's last_status field.  */
3227   if (the_target->thread_stopped == NULL)
3228     {
3229       struct vstop_notif *new_notif = XNEW (struct vstop_notif);
3230
3231       new_notif->ptid = thread->id;
3232       new_notif->status = thread->last_status;
3233       /* Pass the last stop reply back to GDB, but don't notify
3234          yet.  */
3235       notif_event_enque (&notif_stop,
3236                          (struct notif_event *) new_notif);
3237     }
3238   else
3239     {
3240       if (thread_stopped (thread))
3241         {
3242           if (debug_threads)
3243             {
3244               std::string status_string
3245                 = target_waitstatus_to_string (&thread->last_status);
3246
3247               debug_printf ("Reporting thread %s as already stopped with %s\n",
3248                             target_pid_to_str (thread->id),
3249                             status_string.c_str ());
3250             }
3251
3252           gdb_assert (thread->last_status.kind != TARGET_WAITKIND_IGNORE);
3253
3254           /* Pass the last stop reply back to GDB, but don't notify
3255              yet.  */
3256           queue_stop_reply (thread->id, &thread->last_status);
3257         }
3258     }
3259 }
3260
3261 /* Set this inferior threads's state as "want-stopped".  We won't
3262    resume this thread until the client gives us another action for
3263    it.  */
3264
3265 static void
3266 gdb_wants_thread_stopped (thread_info *thread)
3267 {
3268   thread->last_resume_kind = resume_stop;
3269
3270   if (thread->last_status.kind == TARGET_WAITKIND_IGNORE)
3271     {
3272       /* Most threads are stopped implicitly (all-stop); tag that with
3273          signal 0.  */
3274       thread->last_status.kind = TARGET_WAITKIND_STOPPED;
3275       thread->last_status.value.sig = GDB_SIGNAL_0;
3276     }
3277 }
3278
3279 /* Set all threads' states as "want-stopped".  */
3280
3281 static void
3282 gdb_wants_all_threads_stopped (void)
3283 {
3284   for_each_inferior (&all_threads, gdb_wants_thread_stopped);
3285 }
3286
3287 /* Callback for for_each_inferior.  Clear the thread's pending status
3288    flag.  */
3289
3290 static void
3291 clear_pending_status_callback (thread_info *thread)
3292 {
3293   thread->status_pending_p = 0;
3294 }
3295
3296 /* Callback for for_each_inferior.  If the thread is stopped with an
3297    interesting event, mark it as having a pending event.  */
3298
3299 static void
3300 set_pending_status_callback (thread_info *thread)
3301 {
3302   if (thread->last_status.kind != TARGET_WAITKIND_STOPPED
3303       || (thread->last_status.value.sig != GDB_SIGNAL_0
3304           /* A breakpoint, watchpoint or finished step from a previous
3305              GDB run isn't considered interesting for a new GDB run.
3306              If we left those pending, the new GDB could consider them
3307              random SIGTRAPs.  This leaves out real async traps.  We'd
3308              have to peek into the (target-specific) siginfo to
3309              distinguish those.  */
3310           && thread->last_status.value.sig != GDB_SIGNAL_TRAP))
3311     thread->status_pending_p = 1;
3312 }
3313
3314 /* Status handler for the '?' packet.  */
3315
3316 static void
3317 handle_status (char *own_buf)
3318 {
3319   /* GDB is connected, don't forward events to the target anymore.  */
3320   for_each_process ([] (process_info *process) {
3321     process->gdb_detached = 0;
3322   });
3323
3324   /* In non-stop mode, we must send a stop reply for each stopped
3325      thread.  In all-stop mode, just send one for the first stopped
3326      thread we find.  */
3327
3328   if (non_stop)
3329     {
3330       for_each_thread (queue_stop_reply_callback);
3331
3332       /* The first is sent immediatly.  OK is sent if there is no
3333          stopped thread, which is the same handling of the vStopped
3334          packet (by design).  */
3335       notif_write_event (&notif_stop, own_buf);
3336     }
3337   else
3338     {
3339       thread_info *thread = NULL;
3340
3341       pause_all (0);
3342       stabilize_threads ();
3343       gdb_wants_all_threads_stopped ();
3344
3345       /* We can only report one status, but we might be coming out of
3346          non-stop -- if more than one thread is stopped with
3347          interesting events, leave events for the threads we're not
3348          reporting now pending.  They'll be reported the next time the
3349          threads are resumed.  Start by marking all interesting events
3350          as pending.  */
3351       for_each_inferior (&all_threads, set_pending_status_callback);
3352
3353       /* Prefer the last thread that reported an event to GDB (even if
3354          that was a GDB_SIGNAL_TRAP).  */
3355       if (last_status.kind != TARGET_WAITKIND_IGNORE
3356           && last_status.kind != TARGET_WAITKIND_EXITED
3357           && last_status.kind != TARGET_WAITKIND_SIGNALLED)
3358         thread = find_inferior_id (&all_threads, last_ptid);
3359
3360       /* If the last event thread is not found for some reason, look
3361          for some other thread that might have an event to report.  */
3362       if (thread == NULL)
3363         thread = find_thread ([] (thread_info *thread)
3364           {
3365             return thread->status_pending_p;
3366           });
3367
3368       /* If we're still out of luck, simply pick the first thread in
3369          the thread list.  */
3370       if (thread == NULL)
3371         thread = get_first_thread ();
3372
3373       if (thread != NULL)
3374         {
3375           struct thread_info *tp = (struct thread_info *) thread;
3376
3377           /* We're reporting this event, so it's no longer
3378              pending.  */
3379           tp->status_pending_p = 0;
3380
3381           /* GDB assumes the current thread is the thread we're
3382              reporting the status for.  */
3383           general_thread = thread->id;
3384           set_desired_thread ();
3385
3386           gdb_assert (tp->last_status.kind != TARGET_WAITKIND_IGNORE);
3387           prepare_resume_reply (own_buf, tp->id, &tp->last_status);
3388         }
3389       else
3390         strcpy (own_buf, "W00");
3391     }
3392 }
3393
3394 static void
3395 gdbserver_version (void)
3396 {
3397   printf ("GNU gdbserver %s%s\n"
3398           "Copyright (C) 2017 Free Software Foundation, Inc.\n"
3399           "gdbserver is free software, covered by the "
3400           "GNU General Public License.\n"
3401           "This gdbserver was configured as \"%s\"\n",
3402           PKGVERSION, version, host_name);
3403 }
3404
3405 static void
3406 gdbserver_usage (FILE *stream)
3407 {
3408   fprintf (stream, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
3409            "\tgdbserver [OPTIONS] --attach COMM PID\n"
3410            "\tgdbserver [OPTIONS] --multi COMM\n"
3411            "\n"
3412            "COMM may either be a tty device (for serial debugging),\n"
3413            "HOST:PORT to listen for a TCP connection, or '-' or 'stdio' to use \n"
3414            "stdin/stdout of gdbserver.\n"
3415            "PROG is the executable program.  ARGS are arguments passed to inferior.\n"
3416            "PID is the process ID to attach to, when --attach is specified.\n"
3417            "\n"
3418            "Operating modes:\n"
3419            "\n"
3420            "  --attach              Attach to running process PID.\n"
3421            "  --multi               Start server without a specific program, and\n"
3422            "                        only quit when explicitly commanded.\n"
3423            "  --once                Exit after the first connection has closed.\n"
3424            "  --help                Print this message and then exit.\n"
3425            "  --version             Display version information and exit.\n"
3426            "\n"
3427            "Other options:\n"
3428            "\n"
3429            "  --wrapper WRAPPER --  Run WRAPPER to start new programs.\n"
3430            "  --disable-randomization\n"
3431            "                        Run PROG with address space randomization disabled.\n"
3432            "  --no-disable-randomization\n"
3433            "                        Don't disable address space randomization when\n"
3434            "                        starting PROG.\n"
3435            "  --startup-with-shell\n"
3436            "                        Start PROG using a shell.  I.e., execs a shell that\n"
3437            "                        then execs PROG.  (default)\n"
3438            "  --no-startup-with-shell\n"
3439            "                        Exec PROG directly instead of using a shell.\n"
3440            "                        Disables argument globbing and variable substitution\n"
3441            "                        on UNIX-like systems.\n"
3442            "\n"
3443            "Debug options:\n"
3444            "\n"
3445            "  --debug               Enable general debugging output.\n"
3446            "  --debug-format=opt1[,opt2,...]\n"
3447            "                        Specify extra content in debugging output.\n"
3448            "                          Options:\n"
3449            "                            all\n"
3450            "                            none\n"
3451            "                            timestamp\n"
3452            "  --remote-debug        Enable remote protocol debugging output.\n"
3453            "  --disable-packet=opt1[,opt2,...]\n"
3454            "                        Disable support for RSP packets or features.\n"
3455            "                          Options:\n"
3456            "                            vCont, Tthread, qC, qfThreadInfo and \n"
3457            "                            threads (disable all threading packets).\n"
3458            "\n"
3459            "For more information, consult the GDB manual (available as on-line \n"
3460            "info or a printed manual).\n");
3461   if (REPORT_BUGS_TO[0] && stream == stdout)
3462     fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
3463 }
3464
3465 static void
3466 gdbserver_show_disableable (FILE *stream)
3467 {
3468   fprintf (stream, "Disableable packets:\n"
3469            "  vCont       \tAll vCont packets\n"
3470            "  qC          \tQuerying the current thread\n"
3471            "  qfThreadInfo\tThread listing\n"
3472            "  Tthread     \tPassing the thread specifier in the "
3473            "T stop reply packet\n"
3474            "  threads     \tAll of the above\n");
3475 }
3476
3477 static void
3478 kill_inferior_callback (process_info *process)
3479 {
3480   int pid = process->pid;
3481
3482   kill_inferior (pid);
3483   discard_queued_stop_replies (pid_to_ptid (pid));
3484 }
3485
3486 /* Call this when exiting gdbserver with possible inferiors that need
3487    to be killed or detached from.  */
3488
3489 static void
3490 detach_or_kill_for_exit (void)
3491 {
3492   /* First print a list of the inferiors we will be killing/detaching.
3493      This is to assist the user, for example, in case the inferior unexpectedly
3494      dies after we exit: did we screw up or did the inferior exit on its own?
3495      Having this info will save some head-scratching.  */
3496
3497   if (have_started_inferiors_p ())
3498     {
3499       fprintf (stderr, "Killing process(es):");
3500
3501       for_each_process ([] (process_info *process) {
3502         if (!process->attached)
3503           fprintf (stderr, " %d", process->pid);
3504       });
3505
3506       fprintf (stderr, "\n");
3507     }
3508   if (have_attached_inferiors_p ())
3509     {
3510       fprintf (stderr, "Detaching process(es):");
3511
3512       for_each_process ([] (process_info *process) {
3513         if (process->attached)
3514           fprintf (stderr, " %d", process->pid);
3515       });
3516
3517       fprintf (stderr, "\n");
3518     }
3519
3520   /* Now we can kill or detach the inferiors.  */
3521   for_each_process ([] (process_info *process) {
3522     int pid = process->pid;
3523
3524     if (process->attached)
3525       detach_inferior (pid);
3526     else
3527       kill_inferior (pid);
3528
3529     discard_queued_stop_replies (pid_to_ptid (pid));
3530   });
3531 }
3532
3533 /* Value that will be passed to exit(3) when gdbserver exits.  */
3534 static int exit_code;
3535
3536 /* Cleanup version of detach_or_kill_for_exit.  */
3537
3538 static void
3539 detach_or_kill_for_exit_cleanup (void *ignore)
3540 {
3541
3542   TRY
3543     {
3544       detach_or_kill_for_exit ();
3545     }
3546
3547   CATCH (exception, RETURN_MASK_ALL)
3548     {
3549       fflush (stdout);
3550       fprintf (stderr, "Detach or kill failed: %s\n", exception.message);
3551       exit_code = 1;
3552     }
3553   END_CATCH
3554 }
3555
3556 /* Main function.  This is called by the real "main" function,
3557    wrapped in a TRY_CATCH that handles any uncaught exceptions.  */
3558
3559 static void ATTRIBUTE_NORETURN
3560 captured_main (int argc, char *argv[])
3561 {
3562   int bad_attach;
3563   int pid;
3564   char *arg_end;
3565   const char *port = NULL;
3566   char **next_arg = &argv[1];
3567   volatile int multi_mode = 0;
3568   volatile int attach = 0;
3569   int was_running;
3570   bool selftest = false;
3571   const char *selftest_filter = NULL;
3572
3573   while (*next_arg != NULL && **next_arg == '-')
3574     {
3575       if (strcmp (*next_arg, "--version") == 0)
3576         {
3577           gdbserver_version ();
3578           exit (0);
3579         }
3580       else if (strcmp (*next_arg, "--help") == 0)
3581         {
3582           gdbserver_usage (stdout);
3583           exit (0);
3584         }
3585       else if (strcmp (*next_arg, "--attach") == 0)
3586         attach = 1;
3587       else if (strcmp (*next_arg, "--multi") == 0)
3588         multi_mode = 1;
3589       else if (strcmp (*next_arg, "--wrapper") == 0)
3590         {
3591           char **tmp;
3592
3593           next_arg++;
3594
3595           tmp = next_arg;
3596           while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
3597             {
3598               wrapper_argv += *next_arg;
3599               wrapper_argv += ' ';
3600               next_arg++;
3601             }
3602
3603           if (!wrapper_argv.empty ())
3604             {
3605               /* Erase the last whitespace.  */
3606               wrapper_argv.erase (wrapper_argv.end () - 1);
3607             }
3608
3609           if (next_arg == tmp || *next_arg == NULL)
3610             {
3611               gdbserver_usage (stderr);
3612               exit (1);
3613             }
3614
3615           /* Consume the "--".  */
3616           *next_arg = NULL;
3617         }
3618       else if (strcmp (*next_arg, "--debug") == 0)
3619         debug_threads = 1;
3620       else if (startswith (*next_arg, "--debug-format="))
3621         {
3622           char *error_msg
3623             = parse_debug_format_options ((*next_arg)
3624                                           + sizeof ("--debug-format=") - 1, 0);
3625
3626           if (error_msg != NULL)
3627             {
3628               fprintf (stderr, "%s", error_msg);
3629               exit (1);
3630             }
3631         }
3632       else if (strcmp (*next_arg, "--remote-debug") == 0)
3633         remote_debug = 1;
3634       else if (strcmp (*next_arg, "--disable-packet") == 0)
3635         {
3636           gdbserver_show_disableable (stdout);
3637           exit (0);
3638         }
3639       else if (startswith (*next_arg, "--disable-packet="))
3640         {
3641           char *packets, *tok;
3642
3643           packets = *next_arg += sizeof ("--disable-packet=") - 1;
3644           for (tok = strtok (packets, ",");
3645                tok != NULL;
3646                tok = strtok (NULL, ","))
3647             {
3648               if (strcmp ("vCont", tok) == 0)
3649                 disable_packet_vCont = 1;
3650               else if (strcmp ("Tthread", tok) == 0)
3651                 disable_packet_Tthread = 1;
3652               else if (strcmp ("qC", tok) == 0)
3653                 disable_packet_qC = 1;
3654               else if (strcmp ("qfThreadInfo", tok) == 0)
3655                 disable_packet_qfThreadInfo = 1;
3656               else if (strcmp ("threads", tok) == 0)
3657                 {
3658                   disable_packet_vCont = 1;
3659                   disable_packet_Tthread = 1;
3660                   disable_packet_qC = 1;
3661                   disable_packet_qfThreadInfo = 1;
3662                 }
3663               else
3664                 {
3665                   fprintf (stderr, "Don't know how to disable \"%s\".\n\n",
3666                            tok);
3667                   gdbserver_show_disableable (stderr);
3668                   exit (1);
3669                 }
3670             }
3671         }
3672       else if (strcmp (*next_arg, "-") == 0)
3673         {
3674           /* "-" specifies a stdio connection and is a form of port
3675              specification.  */
3676           port = STDIO_CONNECTION_NAME;
3677           next_arg++;
3678           break;
3679         }
3680       else if (strcmp (*next_arg, "--disable-randomization") == 0)
3681         disable_randomization = 1;
3682       else if (strcmp (*next_arg, "--no-disable-randomization") == 0)
3683         disable_randomization = 0;
3684       else if (strcmp (*next_arg, "--startup-with-shell") == 0)
3685         startup_with_shell = true;
3686       else if (strcmp (*next_arg, "--no-startup-with-shell") == 0)
3687         startup_with_shell = false;
3688       else if (strcmp (*next_arg, "--once") == 0)
3689         run_once = 1;
3690       else if (strcmp (*next_arg, "--selftest") == 0)
3691         selftest = true;
3692       else if (startswith (*next_arg, "--selftest="))
3693         {
3694           selftest = true;
3695           selftest_filter = *next_arg + strlen ("--selftest=");
3696         }
3697       else
3698         {
3699           fprintf (stderr, "Unknown argument: %s\n", *next_arg);
3700           exit (1);
3701         }
3702
3703       next_arg++;
3704       continue;
3705     }
3706
3707   if (port == NULL)
3708     {
3709       port = *next_arg;
3710       next_arg++;
3711     }
3712   if ((port == NULL || (!attach && !multi_mode && *next_arg == NULL))
3713        && !selftest)
3714     {
3715       gdbserver_usage (stderr);
3716       exit (1);
3717     }
3718
3719   /* Remember stdio descriptors.  LISTEN_DESC must not be listed, it will be
3720      opened by remote_prepare.  */
3721   notice_open_fds ();
3722
3723   save_original_signals_state ();
3724
3725   /* We need to know whether the remote connection is stdio before
3726      starting the inferior.  Inferiors created in this scenario have
3727      stdin,stdout redirected.  So do this here before we call
3728      start_inferior.  */
3729   if (port != NULL)
3730     remote_prepare (port);
3731
3732   bad_attach = 0;
3733   pid = 0;
3734
3735   /* --attach used to come after PORT, so allow it there for
3736        compatibility.  */
3737   if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
3738     {
3739       attach = 1;
3740       next_arg++;
3741     }
3742
3743   if (attach
3744       && (*next_arg == NULL
3745           || (*next_arg)[0] == '\0'
3746           || (pid = strtoul (*next_arg, &arg_end, 0)) == 0
3747           || *arg_end != '\0'
3748           || next_arg[1] != NULL))
3749     bad_attach = 1;
3750
3751   if (bad_attach)
3752     {
3753       gdbserver_usage (stderr);
3754       exit (1);
3755     }
3756
3757   /* Gather information about the environment.  */
3758   our_environ = gdb_environ::from_host_environ ();
3759
3760   initialize_async_io ();
3761   initialize_low ();
3762   have_job_control ();
3763   initialize_event_loop ();
3764   if (target_supports_tracepoints ())
3765     initialize_tracepoint ();
3766   initialize_notif ();
3767
3768   own_buf = (char *) xmalloc (PBUFSIZ + 1);
3769   mem_buf = (unsigned char *) xmalloc (PBUFSIZ);
3770
3771   if (selftest)
3772     {
3773       selftests::run_tests (selftest_filter);
3774       throw_quit ("Quit");
3775     }
3776
3777   if (pid == 0 && *next_arg != NULL)
3778     {
3779       int i, n;
3780
3781       n = argc - (next_arg - argv);
3782       program_name = xstrdup (next_arg[0]);
3783       for (i = 1; i < n; i++)
3784         program_args.push_back (xstrdup (next_arg[i]));
3785       program_args.push_back (NULL);
3786
3787       /* Wait till we are at first instruction in program.  */
3788       create_inferior (program_name, program_args);
3789
3790       /* We are now (hopefully) stopped at the first instruction of
3791          the target process.  This assumes that the target process was
3792          successfully created.  */
3793     }
3794   else if (pid != 0)
3795     {
3796       if (attach_inferior (pid) == -1)
3797         error ("Attaching not supported on this target");
3798
3799       /* Otherwise succeeded.  */
3800     }
3801   else
3802     {
3803       last_status.kind = TARGET_WAITKIND_EXITED;
3804       last_status.value.integer = 0;
3805       last_ptid = minus_one_ptid;
3806     }
3807   make_cleanup (detach_or_kill_for_exit_cleanup, NULL);
3808
3809   /* Don't report shared library events on the initial connection,
3810      even if some libraries are preloaded.  Avoids the "stopped by
3811      shared library event" notice on gdb side.  */
3812   dlls_changed = 0;
3813
3814   if (last_status.kind == TARGET_WAITKIND_EXITED
3815       || last_status.kind == TARGET_WAITKIND_SIGNALLED)
3816     was_running = 0;
3817   else
3818     was_running = 1;
3819
3820   if (!was_running && !multi_mode)
3821     error ("No program to debug");
3822
3823   while (1)
3824     {
3825
3826       noack_mode = 0;
3827       multi_process = 0;
3828       report_fork_events = 0;
3829       report_vfork_events = 0;
3830       report_exec_events = 0;
3831       /* Be sure we're out of tfind mode.  */
3832       current_traceframe = -1;
3833       cont_thread = null_ptid;
3834       swbreak_feature = 0;
3835       hwbreak_feature = 0;
3836       vCont_supported = 0;
3837
3838       remote_open (port);
3839
3840       TRY
3841         {
3842           /* Wait for events.  This will return when all event sources
3843              are removed from the event loop.  */
3844           start_event_loop ();
3845
3846           /* If an exit was requested (using the "monitor exit"
3847              command), terminate now.  */
3848           if (exit_requested)
3849             throw_quit ("Quit");
3850
3851           /* The only other way to get here is for getpkt to fail:
3852
3853               - If --once was specified, we're done.
3854
3855               - If not in extended-remote mode, and we're no longer
3856                 debugging anything, simply exit: GDB has disconnected
3857                 after processing the last process exit.
3858
3859               - Otherwise, close the connection and reopen it at the
3860                 top of the loop.  */
3861           if (run_once || (!extended_protocol && !target_running ()))
3862             throw_quit ("Quit");
3863
3864           fprintf (stderr,
3865                    "Remote side has terminated connection.  "
3866                    "GDBserver will reopen the connection.\n");
3867
3868           /* Get rid of any pending statuses.  An eventual reconnection
3869              (by the same GDB instance or another) will refresh all its
3870              state from scratch.  */
3871           discard_queued_stop_replies (minus_one_ptid);
3872           for_each_inferior (&all_threads,
3873                              clear_pending_status_callback);
3874
3875           if (tracing)
3876             {
3877               if (disconnected_tracing)
3878                 {
3879                   /* Try to enable non-stop/async mode, so we we can
3880                      both wait for an async socket accept, and handle
3881                      async target events simultaneously.  There's also
3882                      no point either in having the target always stop
3883                      all threads, when we're going to pass signals
3884                      down without informing GDB.  */
3885                   if (!non_stop)
3886                     {
3887                       if (start_non_stop (1))
3888                         non_stop = 1;
3889
3890                       /* Detaching implicitly resumes all threads;
3891                          simply disconnecting does not.  */
3892                     }
3893                 }
3894               else
3895                 {
3896                   fprintf (stderr,
3897                            "Disconnected tracing disabled; "
3898                            "stopping trace run.\n");
3899                   stop_tracing ();
3900                 }
3901             }
3902         }
3903       CATCH (exception, RETURN_MASK_ERROR)
3904         {
3905           fflush (stdout);
3906           fprintf (stderr, "gdbserver: %s\n", exception.message);
3907
3908           if (response_needed)
3909             {
3910               write_enn (own_buf);
3911               putpkt (own_buf);
3912             }
3913
3914           if (run_once)
3915             throw_quit ("Quit");
3916         }
3917       END_CATCH
3918     }
3919 }
3920
3921 /* Main function.  */
3922
3923 int
3924 main (int argc, char *argv[])
3925 {
3926
3927   TRY
3928     {
3929       captured_main (argc, argv);
3930     }
3931   CATCH (exception, RETURN_MASK_ALL)
3932     {
3933       if (exception.reason == RETURN_ERROR)
3934         {
3935           fflush (stdout);
3936           fprintf (stderr, "%s\n", exception.message);
3937           fprintf (stderr, "Exiting\n");
3938           exit_code = 1;
3939         }
3940
3941       exit (exit_code);
3942     }
3943   END_CATCH
3944
3945   gdb_assert_not_reached ("captured_main should never return");
3946 }
3947
3948 /* Process options coming from Z packets for a breakpoint.  PACKET is
3949    the packet buffer.  *PACKET is updated to point to the first char
3950    after the last processed option.  */
3951
3952 static void
3953 process_point_options (struct gdb_breakpoint *bp, const char **packet)
3954 {
3955   const char *dataptr = *packet;
3956   int persist;
3957
3958   /* Check if data has the correct format.  */
3959   if (*dataptr != ';')
3960     return;
3961
3962   dataptr++;
3963
3964   while (*dataptr)
3965     {
3966       if (*dataptr == ';')
3967         ++dataptr;
3968
3969       if (*dataptr == 'X')
3970         {
3971           /* Conditional expression.  */
3972           if (debug_threads)
3973             debug_printf ("Found breakpoint condition.\n");
3974           if (!add_breakpoint_condition (bp, &dataptr))
3975             dataptr = strchrnul (dataptr, ';');
3976         }
3977       else if (startswith (dataptr, "cmds:"))
3978         {
3979           dataptr += strlen ("cmds:");
3980           if (debug_threads)
3981             debug_printf ("Found breakpoint commands %s.\n", dataptr);
3982           persist = (*dataptr == '1');
3983           dataptr += 2;
3984           if (add_breakpoint_commands (bp, &dataptr, persist))
3985             dataptr = strchrnul (dataptr, ';');
3986         }
3987       else
3988         {
3989           fprintf (stderr, "Unknown token %c, ignoring.\n",
3990                    *dataptr);
3991           /* Skip tokens until we find one that we recognize.  */
3992           dataptr = strchrnul (dataptr, ';');
3993         }
3994     }
3995   *packet = dataptr;
3996 }
3997
3998 /* Event loop callback that handles a serial event.  The first byte in
3999    the serial buffer gets us here.  We expect characters to arrive at
4000    a brisk pace, so we read the rest of the packet with a blocking
4001    getpkt call.  */
4002
4003 static int
4004 process_serial_event (void)
4005 {
4006   int signal;
4007   unsigned int len;
4008   int res;
4009   CORE_ADDR mem_addr;
4010   unsigned char sig;
4011   int packet_len;
4012   int new_packet_len = -1;
4013
4014   disable_async_io ();
4015
4016   response_needed = 0;
4017   packet_len = getpkt (own_buf);
4018   if (packet_len <= 0)
4019     {
4020       remote_close ();
4021       /* Force an event loop break.  */
4022       return -1;
4023     }
4024   response_needed = 1;
4025
4026   char ch = own_buf[0];
4027   switch (ch)
4028     {
4029     case 'q':
4030       handle_query (own_buf, packet_len, &new_packet_len);
4031       break;
4032     case 'Q':
4033       handle_general_set (own_buf);
4034       break;
4035     case 'D':
4036       handle_detach (own_buf);
4037       break;
4038     case '!':
4039       extended_protocol = 1;
4040       write_ok (own_buf);
4041       break;
4042     case '?':
4043       handle_status (own_buf);
4044       break;
4045     case 'H':
4046       if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
4047         {
4048           require_running_or_break (own_buf);
4049
4050           ptid_t thread_id = read_ptid (&own_buf[2], NULL);
4051
4052           if (thread_id == null_ptid || thread_id == minus_one_ptid)
4053             thread_id = null_ptid;
4054           else if (thread_id.is_pid ())
4055             {
4056               /* The ptid represents a pid.  */
4057               thread_info *thread = find_any_thread_of_pid (thread_id.pid ());
4058
4059               if (thread == NULL)
4060                 {
4061                   write_enn (own_buf);
4062                   break;
4063                 }
4064
4065               thread_id = thread->id;
4066             }
4067           else
4068             {
4069               /* The ptid represents a lwp/tid.  */
4070               if (find_thread_ptid (thread_id) == NULL)
4071                 {
4072                   write_enn (own_buf);
4073                   break;
4074                 }
4075             }
4076
4077           if (own_buf[1] == 'g')
4078             {
4079               if (ptid_equal (thread_id, null_ptid))
4080                 {
4081                   /* GDB is telling us to choose any thread.  Check if
4082                      the currently selected thread is still valid. If
4083                      it is not, select the first available.  */
4084                   struct thread_info *thread =
4085                     (struct thread_info *) find_inferior_id (&all_threads,
4086                                                              general_thread);
4087                   if (thread == NULL)
4088                     thread = get_first_thread ();
4089                   thread_id = thread->id;
4090                 }
4091
4092               general_thread = thread_id;
4093               set_desired_thread ();
4094               gdb_assert (current_thread != NULL);
4095             }
4096           else if (own_buf[1] == 'c')
4097             cont_thread = thread_id;
4098
4099           write_ok (own_buf);
4100         }
4101       else
4102         {
4103           /* Silently ignore it so that gdb can extend the protocol
4104              without compatibility headaches.  */
4105           own_buf[0] = '\0';
4106         }
4107       break;
4108     case 'g':
4109       require_running_or_break (own_buf);
4110       if (current_traceframe >= 0)
4111         {
4112           struct regcache *regcache
4113             = new_register_cache (current_target_desc ());
4114
4115           if (fetch_traceframe_registers (current_traceframe,
4116                                           regcache, -1) == 0)
4117             registers_to_string (regcache, own_buf);
4118           else
4119             write_enn (own_buf);
4120           free_register_cache (regcache);
4121         }
4122       else
4123         {
4124           struct regcache *regcache;
4125
4126           if (!set_desired_thread ())
4127             write_enn (own_buf);
4128           else
4129             {
4130               regcache = get_thread_regcache (current_thread, 1);
4131               registers_to_string (regcache, own_buf);
4132             }
4133         }
4134       break;
4135     case 'G':
4136       require_running_or_break (own_buf);
4137       if (current_traceframe >= 0)
4138         write_enn (own_buf);
4139       else
4140         {
4141           struct regcache *regcache;
4142
4143           if (!set_desired_thread ())
4144             write_enn (own_buf);
4145           else
4146             {
4147               regcache = get_thread_regcache (current_thread, 1);
4148               registers_from_string (regcache, &own_buf[1]);
4149               write_ok (own_buf);
4150             }
4151         }
4152       break;
4153     case 'm':
4154       require_running_or_break (own_buf);
4155       decode_m_packet (&own_buf[1], &mem_addr, &len);
4156       res = gdb_read_memory (mem_addr, mem_buf, len);
4157       if (res < 0)
4158         write_enn (own_buf);
4159       else
4160         bin2hex (mem_buf, own_buf, res);
4161       break;
4162     case 'M':
4163       require_running_or_break (own_buf);
4164       decode_M_packet (&own_buf[1], &mem_addr, &len, &mem_buf);
4165       if (gdb_write_memory (mem_addr, mem_buf, len) == 0)
4166         write_ok (own_buf);
4167       else
4168         write_enn (own_buf);
4169       break;
4170     case 'X':
4171       require_running_or_break (own_buf);
4172       if (decode_X_packet (&own_buf[1], packet_len - 1,
4173                            &mem_addr, &len, &mem_buf) < 0
4174           || gdb_write_memory (mem_addr, mem_buf, len) != 0)
4175         write_enn (own_buf);
4176       else
4177         write_ok (own_buf);
4178       break;
4179     case 'C':
4180       require_running_or_break (own_buf);
4181       hex2bin (own_buf + 1, &sig, 1);
4182       if (gdb_signal_to_host_p ((enum gdb_signal) sig))
4183         signal = gdb_signal_to_host ((enum gdb_signal) sig);
4184       else
4185         signal = 0;
4186       myresume (own_buf, 0, signal);
4187       break;
4188     case 'S':
4189       require_running_or_break (own_buf);
4190       hex2bin (own_buf + 1, &sig, 1);
4191       if (gdb_signal_to_host_p ((enum gdb_signal) sig))
4192         signal = gdb_signal_to_host ((enum gdb_signal) sig);
4193       else
4194         signal = 0;
4195       myresume (own_buf, 1, signal);
4196       break;
4197     case 'c':
4198       require_running_or_break (own_buf);
4199       signal = 0;
4200       myresume (own_buf, 0, signal);
4201       break;
4202     case 's':
4203       require_running_or_break (own_buf);
4204       signal = 0;
4205       myresume (own_buf, 1, signal);
4206       break;
4207     case 'Z':  /* insert_ ... */
4208       /* Fallthrough.  */
4209     case 'z':  /* remove_ ... */
4210       {
4211         char *dataptr;
4212         ULONGEST addr;
4213         int kind;
4214         char type = own_buf[1];
4215         int res;
4216         const int insert = ch == 'Z';
4217         const char *p = &own_buf[3];
4218
4219         p = unpack_varlen_hex (p, &addr);
4220         kind = strtol (p + 1, &dataptr, 16);
4221
4222         if (insert)
4223           {
4224             struct gdb_breakpoint *bp;
4225
4226             bp = set_gdb_breakpoint (type, addr, kind, &res);
4227             if (bp != NULL)
4228               {
4229                 res = 0;
4230
4231                 /* GDB may have sent us a list of *point parameters to
4232                    be evaluated on the target's side.  Read such list
4233                    here.  If we already have a list of parameters, GDB
4234                    is telling us to drop that list and use this one
4235                    instead.  */
4236                 clear_breakpoint_conditions_and_commands (bp);
4237                 const char *options = dataptr;
4238                 process_point_options (bp, &options);
4239               }
4240           }
4241         else
4242           res = delete_gdb_breakpoint (type, addr, kind);
4243
4244         if (res == 0)
4245           write_ok (own_buf);
4246         else if (res == 1)
4247           /* Unsupported.  */
4248           own_buf[0] = '\0';
4249         else
4250           write_enn (own_buf);
4251         break;
4252       }
4253     case 'k':
4254       response_needed = 0;
4255       if (!target_running ())
4256         /* The packet we received doesn't make sense - but we can't
4257            reply to it, either.  */
4258         return 0;
4259
4260       fprintf (stderr, "Killing all inferiors\n");
4261
4262       for_each_process (kill_inferior_callback);
4263
4264       /* When using the extended protocol, we wait with no program
4265          running.  The traditional protocol will exit instead.  */
4266       if (extended_protocol)
4267         {
4268           last_status.kind = TARGET_WAITKIND_EXITED;
4269           last_status.value.sig = GDB_SIGNAL_KILL;
4270           return 0;
4271         }
4272       else
4273         exit (0);
4274
4275     case 'T':
4276       {
4277         require_running_or_break (own_buf);
4278
4279         ptid_t thread_id = read_ptid (&own_buf[1], NULL);
4280         if (find_thread_ptid (thread_id) == NULL)
4281           {
4282             write_enn (own_buf);
4283             break;
4284           }
4285
4286         if (mythread_alive (thread_id))
4287           write_ok (own_buf);
4288         else
4289           write_enn (own_buf);
4290       }
4291       break;
4292     case 'R':
4293       response_needed = 0;
4294
4295       /* Restarting the inferior is only supported in the extended
4296          protocol.  */
4297       if (extended_protocol)
4298         {
4299           if (target_running ())
4300             for_each_process (kill_inferior_callback);
4301
4302           fprintf (stderr, "GDBserver restarting\n");
4303
4304           /* Wait till we are at 1st instruction in prog.  */
4305           if (program_name != NULL)
4306             {
4307               create_inferior (program_name, program_args);
4308
4309               if (last_status.kind == TARGET_WAITKIND_STOPPED)
4310                 {
4311                   /* Stopped at the first instruction of the target
4312                      process.  */
4313                   general_thread = last_ptid;
4314                 }
4315               else
4316                 {
4317                   /* Something went wrong.  */
4318                   general_thread = null_ptid;
4319                 }
4320             }
4321           else
4322             {
4323               last_status.kind = TARGET_WAITKIND_EXITED;
4324               last_status.value.sig = GDB_SIGNAL_KILL;
4325             }
4326           return 0;
4327         }
4328       else
4329         {
4330           /* It is a request we don't understand.  Respond with an
4331              empty packet so that gdb knows that we don't support this
4332              request.  */
4333           own_buf[0] = '\0';
4334           break;
4335         }
4336     case 'v':
4337       /* Extended (long) request.  */
4338       handle_v_requests (own_buf, packet_len, &new_packet_len);
4339       break;
4340
4341     default:
4342       /* It is a request we don't understand.  Respond with an empty
4343          packet so that gdb knows that we don't support this
4344          request.  */
4345       own_buf[0] = '\0';
4346       break;
4347     }
4348
4349   if (new_packet_len != -1)
4350     putpkt_binary (own_buf, new_packet_len);
4351   else
4352     putpkt (own_buf);
4353
4354   response_needed = 0;
4355
4356   if (exit_requested)
4357     return -1;
4358
4359   return 0;
4360 }
4361
4362 /* Event-loop callback for serial events.  */
4363
4364 int
4365 handle_serial_event (int err, gdb_client_data client_data)
4366 {
4367   if (debug_threads)
4368     debug_printf ("handling possible serial event\n");
4369
4370   /* Really handle it.  */
4371   if (process_serial_event () < 0)
4372     return -1;
4373
4374   /* Be sure to not change the selected thread behind GDB's back.
4375      Important in the non-stop mode asynchronous protocol.  */
4376   set_desired_thread ();
4377
4378   return 0;
4379 }
4380
4381 /* Push a stop notification on the notification queue.  */
4382
4383 static void
4384 push_stop_notification (ptid_t ptid, struct target_waitstatus *status)
4385 {
4386   struct vstop_notif *vstop_notif = XNEW (struct vstop_notif);
4387
4388   vstop_notif->status = *status;
4389   vstop_notif->ptid = ptid;
4390   /* Push Stop notification.  */
4391   notif_push (&notif_stop, (struct notif_event *) vstop_notif);
4392 }
4393
4394 /* Event-loop callback for target events.  */
4395
4396 int
4397 handle_target_event (int err, gdb_client_data client_data)
4398 {
4399   if (debug_threads)
4400     debug_printf ("handling possible target event\n");
4401
4402   last_ptid = mywait (minus_one_ptid, &last_status,
4403                       TARGET_WNOHANG, 1);
4404
4405   if (last_status.kind == TARGET_WAITKIND_NO_RESUMED)
4406     {
4407       if (gdb_connected () && report_no_resumed)
4408         push_stop_notification (null_ptid, &last_status);
4409     }
4410   else if (last_status.kind != TARGET_WAITKIND_IGNORE)
4411     {
4412       int pid = ptid_get_pid (last_ptid);
4413       struct process_info *process = find_process_pid (pid);
4414       int forward_event = !gdb_connected () || process->gdb_detached;
4415
4416       if (last_status.kind == TARGET_WAITKIND_EXITED
4417           || last_status.kind == TARGET_WAITKIND_SIGNALLED)
4418         {
4419           mark_breakpoints_out (process);
4420           target_mourn_inferior (last_ptid);
4421         }
4422       else if (last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
4423         ;
4424       else
4425         {
4426           /* We're reporting this thread as stopped.  Update its
4427              "want-stopped" state to what the client wants, until it
4428              gets a new resume action.  */
4429           current_thread->last_resume_kind = resume_stop;
4430           current_thread->last_status = last_status;
4431         }
4432
4433       if (forward_event)
4434         {
4435           if (!target_running ())
4436             {
4437               /* The last process exited.  We're done.  */
4438               exit (0);
4439             }
4440
4441           if (last_status.kind == TARGET_WAITKIND_EXITED
4442               || last_status.kind == TARGET_WAITKIND_SIGNALLED
4443               || last_status.kind == TARGET_WAITKIND_THREAD_EXITED)
4444             ;
4445           else
4446             {
4447               /* A thread stopped with a signal, but gdb isn't
4448                  connected to handle it.  Pass it down to the
4449                  inferior, as if it wasn't being traced.  */
4450               enum gdb_signal signal;
4451
4452               if (debug_threads)
4453                 debug_printf ("GDB not connected; forwarding event %d for"
4454                               " [%s]\n",
4455                               (int) last_status.kind,
4456                               target_pid_to_str (last_ptid));
4457
4458               if (last_status.kind == TARGET_WAITKIND_STOPPED)
4459                 signal = last_status.value.sig;
4460               else
4461                 signal = GDB_SIGNAL_0;
4462               target_continue (last_ptid, signal);
4463             }
4464         }
4465       else
4466         push_stop_notification (last_ptid, &last_status);
4467     }
4468
4469   /* Be sure to not change the selected thread behind GDB's back.
4470      Important in the non-stop mode asynchronous protocol.  */
4471   set_desired_thread ();
4472
4473   return 0;
4474 }
4475
4476 #if GDB_SELF_TEST
4477 namespace selftests
4478 {
4479
4480 void
4481 reset ()
4482 {}
4483
4484 } // namespace selftests
4485 #endif /* GDB_SELF_TEST */