gdb/gdbserver/server.c

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