gdb/gdbserver/server.c

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