1 /* Main code for remote server for GDB.
2 Copyright (C) 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
36 ptid_t general_thread;
41 static int extended_protocol;
42 static int response_needed;
43 static int exit_requested;
48 static char **program_argv, **wrapper_argv;
50 /* Enable miscellaneous debugging output. The name is historical - it
51 was originally used to debug LinuxThreads support. */
54 /* Enable debugging of h/w breakpoint/watchpoint support. */
57 int pass_signals[TARGET_SIGNAL_LAST];
61 const char *gdbserver_xmltarget;
63 /* The PID of the originally created or attached inferior. Used to
64 send signals to the process when GDB sends us an asynchronous interrupt
65 (user hitting Control-C in the client), and to wait for the child to exit
66 when no longer debugging it. */
68 unsigned long signal_pid;
71 /* A file descriptor for the controlling terminal. */
74 /* TERMINAL_FD's original foreground group. */
75 pid_t old_foreground_pgrp;
77 /* Hand back terminal ownership to the original foreground group. */
80 restore_old_foreground_pgrp (void)
82 tcsetpgrp (terminal_fd, old_foreground_pgrp);
86 /* Set if you want to disable optional thread related packets support
87 in gdbserver, for the sake of testing GDB against stubs that don't
89 int disable_packet_vCont;
90 int disable_packet_Tthread;
91 int disable_packet_qC;
92 int disable_packet_qfThreadInfo;
94 /* Last status reported to GDB. */
95 static struct target_waitstatus last_status;
96 static ptid_t last_ptid;
99 static unsigned char *mem_buf;
101 /* Structure holding information relative to a single stop reply. We
102 keep a queue of these (really a singly-linked list) to push to GDB
106 /* Pointer to next in list. */
107 struct vstop_notif *next;
109 /* Thread or process that got the event. */
113 struct target_waitstatus status;
116 /* The pending stop replies list head. */
117 static struct vstop_notif *notif_queue = NULL;
119 /* Put a stop reply to the stop reply queue. */
122 queue_stop_reply (ptid_t ptid, struct target_waitstatus *status)
124 struct vstop_notif *new_notif;
126 new_notif = malloc (sizeof (*new_notif));
127 new_notif->next = NULL;
128 new_notif->ptid = ptid;
129 new_notif->status = *status;
133 struct vstop_notif *tail;
134 for (tail = notif_queue;
138 tail->next = new_notif;
141 notif_queue = new_notif;
146 struct vstop_notif *n;
148 for (n = notif_queue; n; n = n->next)
151 fprintf (stderr, "pending stop replies: %d\n", i);
155 /* Place an event in the stop reply queue, and push a notification if
156 we aren't sending one yet. */
159 push_event (ptid_t ptid, struct target_waitstatus *status)
161 queue_stop_reply (ptid, status);
163 /* If this is the first stop reply in the queue, then inform GDB
164 about it, by sending a Stop notification. */
165 if (notif_queue->next == NULL)
170 prepare_resume_reply (p,
171 notif_queue->ptid, ¬if_queue->status);
172 putpkt_notif (own_buf);
176 /* Get rid of the currently pending stop replies for PID. If PID is
177 -1, then apply to all processes. */
180 discard_queued_stop_replies (int pid)
182 struct vstop_notif *prev = NULL, *reply, *next;
184 for (reply = notif_queue; reply; reply = next)
189 || ptid_get_pid (reply->ptid) == pid)
191 if (reply == notif_queue)
194 prev->next = reply->next;
203 /* If there are more stop replies to push, push one now. */
206 send_next_stop_reply (char *own_buf)
209 prepare_resume_reply (own_buf,
211 ¬if_queue->status);
217 target_running (void)
219 return all_threads.head != NULL;
223 start_inferior (char **argv)
225 char **new_argv = argv;
227 if (wrapper_argv != NULL)
231 for (i = 0; wrapper_argv[i] != NULL; i++)
233 for (i = 0; argv[i] != NULL; i++)
235 new_argv = alloca (sizeof (char *) * count);
237 for (i = 0; wrapper_argv[i] != NULL; i++)
238 new_argv[count++] = wrapper_argv[i];
239 for (i = 0; argv[i] != NULL; i++)
240 new_argv[count++] = argv[i];
241 new_argv[count] = NULL;
245 signal (SIGTTOU, SIG_DFL);
246 signal (SIGTTIN, SIG_DFL);
249 signal_pid = create_inferior (new_argv[0], new_argv);
251 /* FIXME: we don't actually know at this point that the create
252 actually succeeded. We won't know that until we wait. */
253 fprintf (stderr, "Process %s created; pid = %ld\n", argv[0],
258 signal (SIGTTOU, SIG_IGN);
259 signal (SIGTTIN, SIG_IGN);
260 terminal_fd = fileno (stderr);
261 old_foreground_pgrp = tcgetpgrp (terminal_fd);
262 tcsetpgrp (terminal_fd, signal_pid);
263 atexit (restore_old_foreground_pgrp);
266 if (wrapper_argv != NULL)
268 struct thread_resume resume_info;
271 resume_info.thread = pid_to_ptid (signal_pid);
272 resume_info.kind = resume_continue;
275 ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
277 if (last_status.kind != TARGET_WAITKIND_STOPPED)
282 (*the_target->resume) (&resume_info, 1);
284 mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
285 if (last_status.kind != TARGET_WAITKIND_STOPPED)
288 while (last_status.value.sig != TARGET_SIGNAL_TRAP);
293 /* Wait till we are at 1st instruction in program, return new pid
294 (assuming success). */
295 last_ptid = mywait (pid_to_ptid (signal_pid), &last_status, 0, 0);
301 attach_inferior (int pid)
303 /* myattach should return -1 if attaching is unsupported,
304 0 if it succeeded, and call error() otherwise. */
306 if (myattach (pid) != 0)
309 fprintf (stderr, "Attached; pid = %d\n", pid);
312 /* FIXME - It may be that we should get the SIGNAL_PID from the
313 attach function, so that it can be the main thread instead of
314 whichever we were told to attach to. */
319 last_ptid = mywait (pid_to_ptid (pid), &last_status, 0, 0);
321 /* GDB knows to ignore the first SIGSTOP after attaching to a running
322 process using the "attach" command, but this is different; it's
323 just using "target remote". Pretend it's just starting up. */
324 if (last_status.kind == TARGET_WAITKIND_STOPPED
325 && last_status.value.sig == TARGET_SIGNAL_STOP)
326 last_status.value.sig = TARGET_SIGNAL_TRAP;
332 extern int remote_debug;
334 /* Decode a qXfer read request. Return 0 if everything looks OK,
338 decode_xfer_read (char *buf, char **annex, CORE_ADDR *ofs, unsigned int *len)
340 /* Extract and NUL-terminate the annex. */
342 while (*buf && *buf != ':')
348 /* After the read marker and annex, qXfer looks like a
349 traditional 'm' packet. */
350 decode_m_packet (buf, ofs, len);
355 /* Write the response to a successful qXfer read. Returns the
356 length of the (binary) data stored in BUF, corresponding
357 to as much of DATA/LEN as we could fit. IS_MORE controls
358 the first character of the response. */
360 write_qxfer_response (char *buf, const void *data, int len, int is_more)
369 return remote_escape_output (data, len, (unsigned char *) buf + 1, &out_len,
373 /* Handle all of the extended 'Q' packets. */
375 handle_general_set (char *own_buf)
377 if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0)
379 int numsigs = (int) TARGET_SIGNAL_LAST, i;
380 const char *p = own_buf + strlen ("QPassSignals:");
383 p = decode_address_to_semicolon (&cursig, p);
384 for (i = 0; i < numsigs; i++)
390 /* Keep looping, to clear the remaining signals. */
393 p = decode_address_to_semicolon (&cursig, p);
398 strcpy (own_buf, "OK");
402 if (strcmp (own_buf, "QStartNoAckMode") == 0)
406 fprintf (stderr, "[noack mode enabled]\n");
415 if (strncmp (own_buf, "QNonStop:", 9) == 0)
417 char *mode = own_buf + 9;
421 if (strcmp (mode, "0") == 0)
423 else if (strcmp (mode, "1") == 0)
427 /* We don't know what this mode is, so complain to
429 fprintf (stderr, "Unknown non-stop mode requested: %s\n",
435 req_str = req ? "non-stop" : "all-stop";
436 if (start_non_stop (req) != 0)
438 fprintf (stderr, "Setting %s mode failed\n", req_str);
446 fprintf (stderr, "[%s mode enabled]\n", req_str);
452 /* Otherwise we didn't know what packet it was. Say we didn't
458 get_features_xml (const char *annex)
460 /* gdbserver_xmltarget defines what to return when looking
461 for the "target.xml" file. Its contents can either be
462 verbatim XML code (prefixed with a '@') or else the name
463 of the actual XML file to be used in place of "target.xml".
465 This variable is set up from the auto-generated
466 init_registers_... routine for the current target. */
468 if (gdbserver_xmltarget
469 && strcmp (annex, "target.xml") == 0)
471 if (*gdbserver_xmltarget == '@')
472 return gdbserver_xmltarget + 1;
474 annex = gdbserver_xmltarget;
479 extern const char *const xml_builtin[][2];
482 /* Look for the annex. */
483 for (i = 0; xml_builtin[i][0] != NULL; i++)
484 if (strcmp (annex, xml_builtin[i][0]) == 0)
487 if (xml_builtin[i][0] != NULL)
488 return xml_builtin[i][1];
496 monitor_show_help (void)
498 monitor_output ("The following monitor commands are supported:\n");
499 monitor_output (" set debug <0|1>\n");
500 monitor_output (" Enable general debugging messages\n");
501 monitor_output (" set debug-hw-points <0|1>\n");
502 monitor_output (" Enable h/w breakpoint/watchpoint debugging messages\n");
503 monitor_output (" set remote-debug <0|1>\n");
504 monitor_output (" Enable remote protocol debugging messages\n");
505 monitor_output (" exit\n");
506 monitor_output (" Quit GDBserver\n");
509 /* Subroutine of handle_search_memory to simplify it. */
512 handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len,
513 gdb_byte *pattern, unsigned pattern_len,
514 gdb_byte *search_buf,
515 unsigned chunk_size, unsigned search_buf_size,
516 CORE_ADDR *found_addrp)
518 /* Prime the search buffer. */
520 if (read_inferior_memory (start_addr, search_buf, search_buf_size) != 0)
522 warning ("Unable to access target memory at 0x%lx, halting search.",
527 /* Perform the search.
529 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
530 When we've scanned N bytes we copy the trailing bytes to the start and
531 read in another N bytes. */
533 while (search_space_len >= pattern_len)
536 unsigned nr_search_bytes = (search_space_len < search_buf_size
540 found_ptr = memmem (search_buf, nr_search_bytes, pattern, pattern_len);
542 if (found_ptr != NULL)
544 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
545 *found_addrp = found_addr;
549 /* Not found in this chunk, skip to next chunk. */
551 /* Don't let search_space_len wrap here, it's unsigned. */
552 if (search_space_len >= chunk_size)
553 search_space_len -= chunk_size;
555 search_space_len = 0;
557 if (search_space_len >= pattern_len)
559 unsigned keep_len = search_buf_size - chunk_size;
560 CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
563 /* Copy the trailing part of the previous iteration to the front
564 of the buffer for the next iteration. */
565 memcpy (search_buf, search_buf + chunk_size, keep_len);
567 nr_to_read = (search_space_len - keep_len < chunk_size
568 ? search_space_len - keep_len
571 if (read_inferior_memory (read_addr, search_buf + keep_len,
574 warning ("Unable to access target memory at 0x%lx, halting search.",
579 start_addr += chunk_size;
588 /* Handle qSearch:memory packets. */
591 handle_search_memory (char *own_buf, int packet_len)
593 CORE_ADDR start_addr;
594 CORE_ADDR search_space_len;
596 unsigned int pattern_len;
597 /* NOTE: also defined in find.c testcase. */
598 #define SEARCH_CHUNK_SIZE 16000
599 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
600 /* Buffer to hold memory contents for searching. */
601 gdb_byte *search_buf;
602 unsigned search_buf_size;
604 CORE_ADDR found_addr;
605 int cmd_name_len = sizeof ("qSearch:memory:") - 1;
607 pattern = malloc (packet_len);
610 error ("Unable to allocate memory to perform the search");
611 strcpy (own_buf, "E00");
614 if (decode_search_memory_packet (own_buf + cmd_name_len,
615 packet_len - cmd_name_len,
616 &start_addr, &search_space_len,
617 pattern, &pattern_len) < 0)
620 error ("Error in parsing qSearch:memory packet");
621 strcpy (own_buf, "E00");
625 search_buf_size = chunk_size + pattern_len - 1;
627 /* No point in trying to allocate a buffer larger than the search space. */
628 if (search_space_len < search_buf_size)
629 search_buf_size = search_space_len;
631 search_buf = malloc (search_buf_size);
632 if (search_buf == NULL)
635 error ("Unable to allocate memory to perform the search");
636 strcpy (own_buf, "E00");
640 found = handle_search_memory_1 (start_addr, search_space_len,
641 pattern, pattern_len,
642 search_buf, chunk_size, search_buf_size,
646 sprintf (own_buf, "1,%lx", (long) found_addr);
648 strcpy (own_buf, "0");
650 strcpy (own_buf, "E00");
656 #define require_running(BUF) \
657 if (!target_running ()) \
663 /* Handle monitor commands not handled by target-specific handlers. */
666 handle_monitor_command (char *mon)
668 if (strcmp (mon, "set debug 1") == 0)
671 monitor_output ("Debug output enabled.\n");
673 else if (strcmp (mon, "set debug 0") == 0)
676 monitor_output ("Debug output disabled.\n");
678 else if (strcmp (mon, "set debug-hw-points 1") == 0)
681 monitor_output ("H/W point debugging output enabled.\n");
683 else if (strcmp (mon, "set debug-hw-points 0") == 0)
686 monitor_output ("H/W point debugging output disabled.\n");
688 else if (strcmp (mon, "set remote-debug 1") == 0)
691 monitor_output ("Protocol debug output enabled.\n");
693 else if (strcmp (mon, "set remote-debug 0") == 0)
696 monitor_output ("Protocol debug output disabled.\n");
698 else if (strcmp (mon, "help") == 0)
699 monitor_show_help ();
700 else if (strcmp (mon, "exit") == 0)
704 monitor_output ("Unknown monitor command.\n\n");
705 monitor_show_help ();
711 handle_threads_qxfer_proper (struct buffer *buffer)
713 struct inferior_list_entry *thread;
715 buffer_grow_str (buffer, "<threads>\n");
717 for (thread = all_threads.head; thread; thread = thread->next)
719 ptid_t ptid = thread_to_gdb_id ((struct thread_info *)thread);
724 write_ptid (ptid_s, ptid);
726 if (the_target->core_of_thread)
727 core = (*the_target->core_of_thread) (ptid);
731 sprintf (core_s, "%d", core);
732 buffer_xml_printf (buffer, "<thread id=\"%s\" core=\"%s\"/>\n",
737 buffer_xml_printf (buffer, "<thread id=\"%s\"/>\n",
742 buffer_grow_str0 (buffer, "</threads>\n");
746 handle_threads_qxfer (const char *annex,
747 unsigned char *readbuf,
748 CORE_ADDR offset, int length)
750 static char *result = 0;
751 static unsigned int result_length = 0;
753 if (annex && strcmp (annex, "") != 0)
758 struct buffer buffer;
759 /* When asked for data at offset 0, generate everything and store into
760 'result'. Successive reads will be served off 'result'. */
764 buffer_init (&buffer);
766 handle_threads_qxfer_proper (&buffer);
768 result = buffer_finish (&buffer);
769 result_length = strlen (result);
770 buffer_free (&buffer);
773 if (offset >= result_length)
775 /* We're out of data. */
782 if (length > result_length - offset)
783 length = result_length - offset;
785 memcpy (readbuf, result + offset, length);
791 /* Table used by the crc32 function to calcuate the checksum. */
793 static unsigned int crc32_table[256] =
796 /* Compute 32 bit CRC from inferior memory.
798 On success, return 32 bit CRC.
799 On failure, return (unsigned long long) -1. */
801 static unsigned long long
802 crc32 (CORE_ADDR base, int len, unsigned int crc)
806 /* Initialize the CRC table and the decoding table. */
810 for (i = 0; i < 256; i++)
812 for (c = i << 24, j = 8; j > 0; --j)
813 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
820 unsigned char byte = 0;
822 /* Return failure if memory read fails. */
823 if (read_inferior_memory (base, &byte, 1) != 0)
824 return (unsigned long long) -1;
826 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ byte) & 255];
829 return (unsigned long long) crc;
832 /* Handle all of the extended 'q' packets. */
834 handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
836 static struct inferior_list_entry *thread_ptr;
838 /* Reply the current thread id. */
839 if (strcmp ("qC", own_buf) == 0 && !disable_packet_qC)
842 require_running (own_buf);
844 if (!ptid_equal (general_thread, null_ptid)
845 && !ptid_equal (general_thread, minus_one_ptid))
846 gdb_id = general_thread;
849 thread_ptr = all_threads.head;
850 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
853 sprintf (own_buf, "QC");
855 own_buf = write_ptid (own_buf, gdb_id);
859 if (strcmp ("qSymbol::", own_buf) == 0)
861 /* GDB is suggesting new symbols have been loaded. This may
862 mean a new shared library has been detected as loaded, so
863 take the opportunity to check if breakpoints we think are
864 inserted, still are. Note that it isn't guaranteed that
865 we'll see this when a shared library is loaded, and nor will
866 we see this for unloads (although breakpoints in unloaded
867 libraries shouldn't trigger), as GDB may not find symbols for
868 the library at all. We also re-validate breakpoints when we
869 see a second GDB breakpoint for the same address, and or when
870 we access breakpoint shadows. */
871 validate_breakpoints ();
873 if (target_running () && the_target->look_up_symbols != NULL)
874 (*the_target->look_up_symbols) ();
876 strcpy (own_buf, "OK");
880 if (!disable_packet_qfThreadInfo)
882 if (strcmp ("qfThreadInfo", own_buf) == 0)
886 require_running (own_buf);
887 thread_ptr = all_threads.head;
890 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
891 write_ptid (own_buf, gdb_id);
892 thread_ptr = thread_ptr->next;
896 if (strcmp ("qsThreadInfo", own_buf) == 0)
900 require_running (own_buf);
901 if (thread_ptr != NULL)
904 gdb_id = thread_to_gdb_id ((struct thread_info *)thread_ptr);
905 write_ptid (own_buf, gdb_id);
906 thread_ptr = thread_ptr->next;
911 sprintf (own_buf, "l");
917 if (the_target->read_offsets != NULL
918 && strcmp ("qOffsets", own_buf) == 0)
920 CORE_ADDR text, data;
922 require_running (own_buf);
923 if (the_target->read_offsets (&text, &data))
924 sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
925 (long)text, (long)data, (long)data);
932 if (the_target->qxfer_spu != NULL
933 && strncmp ("qXfer:spu:read:", own_buf, 15) == 0)
939 unsigned char *spu_buf;
941 require_running (own_buf);
942 strcpy (own_buf, "E00");
943 if (decode_xfer_read (own_buf + 15, &annex, &ofs, &len) < 0)
945 if (len > PBUFSIZ - 2)
947 spu_buf = malloc (len + 1);
951 n = (*the_target->qxfer_spu) (annex, spu_buf, NULL, ofs, len + 1);
955 *new_packet_len_p = write_qxfer_response (own_buf, spu_buf, len, 1);
957 *new_packet_len_p = write_qxfer_response (own_buf, spu_buf, n, 0);
963 if (the_target->qxfer_spu != NULL
964 && strncmp ("qXfer:spu:write:", own_buf, 16) == 0)
970 unsigned char *spu_buf;
972 require_running (own_buf);
973 strcpy (own_buf, "E00");
974 spu_buf = malloc (packet_len - 15);
977 if (decode_xfer_write (own_buf + 16, packet_len - 16, &annex,
978 &ofs, &len, spu_buf) < 0)
984 n = (*the_target->qxfer_spu)
985 (annex, NULL, (unsigned const char *)spu_buf, ofs, len);
989 sprintf (own_buf, "%x", n);
995 if (the_target->read_auxv != NULL
996 && strncmp ("qXfer:auxv:read:", own_buf, 16) == 0)
1004 require_running (own_buf);
1006 /* Reject any annex; grab the offset and length. */
1007 if (decode_xfer_read (own_buf + 16, &annex, &ofs, &len) < 0
1008 || annex[0] != '\0')
1010 strcpy (own_buf, "E00");
1014 /* Read one extra byte, as an indicator of whether there is
1016 if (len > PBUFSIZ - 2)
1018 data = malloc (len + 1);
1021 write_enn (own_buf);
1024 n = (*the_target->read_auxv) (ofs, data, len + 1);
1026 write_enn (own_buf);
1028 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
1030 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
1037 if (strncmp ("qXfer:features:read:", own_buf, 20) == 0)
1040 unsigned int len, total_len;
1041 const char *document;
1044 require_running (own_buf);
1046 /* Grab the annex, offset, and length. */
1047 if (decode_xfer_read (own_buf + 20, &annex, &ofs, &len) < 0)
1049 strcpy (own_buf, "E00");
1053 /* Now grab the correct annex. */
1054 document = get_features_xml (annex);
1055 if (document == NULL)
1057 strcpy (own_buf, "E00");
1061 total_len = strlen (document);
1062 if (len > PBUFSIZ - 2)
1065 if (ofs > total_len)
1066 write_enn (own_buf);
1067 else if (len < total_len - ofs)
1068 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
1071 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
1072 total_len - ofs, 0);
1077 if (strncmp ("qXfer:libraries:read:", own_buf, 21) == 0)
1080 unsigned int len, total_len;
1082 struct inferior_list_entry *dll_ptr;
1085 require_running (own_buf);
1087 /* Reject any annex; grab the offset and length. */
1088 if (decode_xfer_read (own_buf + 21, &annex, &ofs, &len) < 0
1089 || annex[0] != '\0')
1091 strcpy (own_buf, "E00");
1095 /* Over-estimate the necessary memory. Assume that every character
1096 in the library name must be escaped. */
1098 for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
1099 total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name);
1101 document = malloc (total_len);
1102 if (document == NULL)
1104 write_enn (own_buf);
1107 strcpy (document, "<library-list>\n");
1108 p = document + strlen (document);
1110 for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
1112 struct dll_info *dll = (struct dll_info *) dll_ptr;
1115 strcpy (p, " <library name=\"");
1117 name = xml_escape_text (dll->name);
1121 strcpy (p, "\"><segment address=\"");
1123 sprintf (p, "0x%lx", (long) dll->base_addr);
1125 strcpy (p, "\"/></library>\n");
1129 strcpy (p, "</library-list>\n");
1131 total_len = strlen (document);
1132 if (len > PBUFSIZ - 2)
1135 if (ofs > total_len)
1136 write_enn (own_buf);
1137 else if (len < total_len - ofs)
1138 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
1141 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
1142 total_len - ofs, 0);
1148 if (the_target->qxfer_osdata != NULL
1149 && strncmp ("qXfer:osdata:read:", own_buf, 18) == 0)
1155 unsigned char *workbuf;
1157 strcpy (own_buf, "E00");
1158 if (decode_xfer_read (own_buf + 18, &annex, &ofs, &len) < 0)
1160 if (len > PBUFSIZ - 2)
1162 workbuf = malloc (len + 1);
1166 n = (*the_target->qxfer_osdata) (annex, workbuf, NULL, ofs, len + 1);
1168 write_enn (own_buf);
1170 *new_packet_len_p = write_qxfer_response (own_buf, workbuf, len, 1);
1172 *new_packet_len_p = write_qxfer_response (own_buf, workbuf, n, 0);
1178 if (the_target->qxfer_siginfo != NULL
1179 && strncmp ("qXfer:siginfo:read:", own_buf, 19) == 0)
1181 unsigned char *data;
1187 require_running (own_buf);
1189 /* Reject any annex; grab the offset and length. */
1190 if (decode_xfer_read (own_buf + 19, &annex, &ofs, &len) < 0
1191 || annex[0] != '\0')
1193 strcpy (own_buf, "E00");
1197 /* Read one extra byte, as an indicator of whether there is
1199 if (len > PBUFSIZ - 2)
1201 data = malloc (len + 1);
1204 n = (*the_target->qxfer_siginfo) (annex, data, NULL, ofs, len + 1);
1206 write_enn (own_buf);
1208 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
1210 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
1216 if (the_target->qxfer_siginfo != NULL
1217 && strncmp ("qXfer:siginfo:write:", own_buf, 20) == 0)
1223 unsigned char *data;
1225 require_running (own_buf);
1227 strcpy (own_buf, "E00");
1228 data = malloc (packet_len - 19);
1231 if (decode_xfer_write (own_buf + 20, packet_len - 20, &annex,
1232 &ofs, &len, data) < 0)
1238 n = (*the_target->qxfer_siginfo)
1239 (annex, NULL, (unsigned const char *)data, ofs, len);
1241 write_enn (own_buf);
1243 sprintf (own_buf, "%x", n);
1249 if (strncmp ("qXfer:threads:read:", own_buf, 19) == 0)
1251 unsigned char *data;
1257 require_running (own_buf);
1259 /* Reject any annex; grab the offset and length. */
1260 if (decode_xfer_read (own_buf + 19, &annex, &ofs, &len) < 0
1261 || annex[0] != '\0')
1263 strcpy (own_buf, "E00");
1267 /* Read one extra byte, as an indicator of whether there is
1269 if (len > PBUFSIZ - 2)
1271 data = malloc (len + 1);
1274 n = handle_threads_qxfer (annex, data, ofs, len + 1);
1276 write_enn (own_buf);
1278 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
1280 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
1286 /* Protocol features query. */
1287 if (strncmp ("qSupported", own_buf, 10) == 0
1288 && (own_buf[10] == ':' || own_buf[10] == '\0'))
1290 char *p = &own_buf[10];
1292 /* Process each feature being provided by GDB. The first
1293 feature will follow a ':', and latter features will follow
1296 for (p = strtok (p + 1, ";");
1298 p = strtok (NULL, ";"))
1300 if (strcmp (p, "multiprocess+") == 0)
1302 /* GDB supports and wants multi-process support if
1304 if (target_supports_multi_process ())
1309 sprintf (own_buf, "PacketSize=%x;QPassSignals+", PBUFSIZ - 1);
1311 /* We do not have any hook to indicate whether the target backend
1312 supports qXfer:libraries:read, so always report it. */
1313 strcat (own_buf, ";qXfer:libraries:read+");
1315 if (the_target->read_auxv != NULL)
1316 strcat (own_buf, ";qXfer:auxv:read+");
1318 if (the_target->qxfer_spu != NULL)
1319 strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
1321 if (the_target->qxfer_siginfo != NULL)
1322 strcat (own_buf, ";qXfer:siginfo:read+;qXfer:siginfo:write+");
1324 /* We always report qXfer:features:read, as targets may
1325 install XML files on a subsequent call to arch_setup.
1326 If we reported to GDB on startup that we don't support
1327 qXfer:feature:read at all, we will never be re-queried. */
1328 strcat (own_buf, ";qXfer:features:read+");
1330 if (transport_is_reliable)
1331 strcat (own_buf, ";QStartNoAckMode+");
1333 if (the_target->qxfer_osdata != NULL)
1334 strcat (own_buf, ";qXfer:osdata:read+");
1336 if (target_supports_multi_process ())
1337 strcat (own_buf, ";multiprocess+");
1339 if (target_supports_non_stop ())
1340 strcat (own_buf, ";QNonStop+");
1342 strcat (own_buf, ";qXfer:threads:read+");
1347 /* Thread-local storage support. */
1348 if (the_target->get_tls_address != NULL
1349 && strncmp ("qGetTLSAddr:", own_buf, 12) == 0)
1351 char *p = own_buf + 12;
1352 CORE_ADDR parts[2], address = 0;
1354 ptid_t ptid = null_ptid;
1356 require_running (own_buf);
1358 for (i = 0; i < 3; i++)
1366 p2 = strchr (p, ',');
1379 ptid = read_ptid (p, NULL);
1381 decode_address (&parts[i - 1], p, len);
1385 if (p != NULL || i < 3)
1389 struct thread_info *thread = find_thread_ptid (ptid);
1394 err = the_target->get_tls_address (thread, parts[0], parts[1],
1400 sprintf (own_buf, "%llx", address);
1405 write_enn (own_buf);
1409 /* Otherwise, pretend we do not understand this packet. */
1412 /* Handle "monitor" commands. */
1413 if (strncmp ("qRcmd,", own_buf, 6) == 0)
1415 char *mon = malloc (PBUFSIZ);
1416 int len = strlen (own_buf + 6);
1420 write_enn (own_buf);
1424 if ((len % 2) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2)
1426 write_enn (own_buf);
1430 mon[len / 2] = '\0';
1434 if (the_target->handle_monitor_command == NULL
1435 || (*the_target->handle_monitor_command) (mon) == 0)
1436 /* Default processing. */
1437 handle_monitor_command (mon);
1443 if (strncmp ("qSearch:memory:", own_buf, sizeof ("qSearch:memory:") - 1) == 0)
1445 require_running (own_buf);
1446 handle_search_memory (own_buf, packet_len);
1450 if (strcmp (own_buf, "qAttached") == 0
1451 || strncmp (own_buf, "qAttached:", sizeof ("qAttached:") - 1) == 0)
1453 struct process_info *process;
1455 if (own_buf[sizeof ("qAttached") - 1])
1457 int pid = strtoul (own_buf + sizeof ("qAttached:") - 1, NULL, 16);
1458 process = (struct process_info *)
1459 find_inferior_id (&all_processes, pid_to_ptid (pid));
1463 require_running (own_buf);
1464 process = current_process ();
1467 if (process == NULL)
1469 write_enn (own_buf);
1473 strcpy (own_buf, process->attached ? "1" : "0");
1477 if (strncmp ("qCRC:", own_buf, 5) == 0)
1479 /* CRC check (compare-section). */
1483 unsigned long long crc;
1485 require_running (own_buf);
1486 base = strtoul (own_buf + 5, &comma, 16);
1487 if (*comma++ != ',')
1489 write_enn (own_buf);
1492 len = strtoul (comma, NULL, 16);
1493 crc = crc32 (base, len, 0xffffffff);
1494 /* Check for memory failure. */
1495 if (crc == (unsigned long long) -1)
1497 write_enn (own_buf);
1500 sprintf (own_buf, "C%lx", (unsigned long) crc);
1504 /* Otherwise we didn't know what packet it was. Say we didn't
1509 /* Parse vCont packets. */
1511 handle_v_cont (char *own_buf)
1515 struct thread_resume *resume_info;
1516 struct thread_resume default_action = {{0}};
1518 /* Count the number of semicolons in the packet. There should be one
1519 for every action. */
1525 p = strchr (p, ';');
1528 resume_info = malloc (n * sizeof (resume_info[0]));
1529 if (resume_info == NULL)
1537 if (p[0] == 's' || p[0] == 'S')
1538 resume_info[i].kind = resume_step;
1539 else if (p[0] == 'c' || p[0] == 'C')
1540 resume_info[i].kind = resume_continue;
1541 else if (p[0] == 't')
1542 resume_info[i].kind = resume_stop;
1546 if (p[0] == 'S' || p[0] == 'C')
1549 sig = strtol (p + 1, &q, 16);
1554 if (!target_signal_to_host_p (sig))
1556 resume_info[i].sig = target_signal_to_host (sig);
1560 resume_info[i].sig = 0;
1566 resume_info[i].thread = minus_one_ptid;
1567 default_action = resume_info[i];
1569 /* Note: we don't increment i here, we'll overwrite this entry
1570 the next time through. */
1572 else if (p[0] == ':')
1574 ptid_t ptid = read_ptid (p + 1, &q);
1579 if (p[0] != ';' && p[0] != 0)
1582 resume_info[i].thread = ptid;
1589 resume_info[i] = default_action;
1591 /* Still used in occasional places in the backend. */
1593 && !ptid_equal (resume_info[0].thread, minus_one_ptid)
1594 && resume_info[0].kind != resume_stop)
1595 cont_thread = resume_info[0].thread;
1597 cont_thread = minus_one_ptid;
1598 set_desired_inferior (0);
1603 (*the_target->resume) (resume_info, n);
1611 last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
1612 prepare_resume_reply (own_buf, last_ptid, &last_status);
1613 disable_async_io ();
1618 write_enn (own_buf);
1623 /* Attach to a new program. Return 1 if successful, 0 if failure. */
1625 handle_v_attach (char *own_buf)
1629 pid = strtol (own_buf + 8, NULL, 16);
1630 if (pid != 0 && attach_inferior (pid) == 0)
1632 /* Don't report shared library events after attaching, even if
1633 some libraries are preloaded. GDB will always poll the
1634 library list. Avoids the "stopped by shared library event"
1635 notice on the GDB side. */
1640 /* In non-stop, we don't send a resume reply. Stop events
1641 will follow up using the normal notification
1646 prepare_resume_reply (own_buf, last_ptid, &last_status);
1652 write_enn (own_buf);
1657 /* Run a new program. Return 1 if successful, 0 if failure. */
1659 handle_v_run (char *own_buf)
1661 char *p, *next_p, **new_argv;
1665 for (p = own_buf + strlen ("vRun;"); p && *p; p = strchr (p, ';'))
1671 new_argv = calloc (new_argc + 2, sizeof (char *));
1672 if (new_argv == NULL)
1674 write_enn (own_buf);
1679 for (p = own_buf + strlen ("vRun;"); *p; p = next_p)
1681 next_p = strchr (p, ';');
1683 next_p = p + strlen (p);
1685 if (i == 0 && p == next_p)
1689 /* FIXME: Fail request if out of memory instead of dying. */
1690 new_argv[i] = xmalloc (1 + (next_p - p) / 2);
1691 unhexify (new_argv[i], p, (next_p - p) / 2);
1692 new_argv[i][(next_p - p) / 2] = '\0';
1701 if (new_argv[0] == NULL)
1703 /* GDB didn't specify a program to run. Use the program from the
1704 last run with the new argument list. */
1706 if (program_argv == NULL)
1708 /* FIXME: new_argv memory leak */
1709 write_enn (own_buf);
1713 new_argv[0] = strdup (program_argv[0]);
1714 if (new_argv[0] == NULL)
1716 /* FIXME: new_argv memory leak */
1717 write_enn (own_buf);
1722 /* Free the old argv and install the new one. */
1723 freeargv (program_argv);
1724 program_argv = new_argv;
1726 start_inferior (program_argv);
1727 if (last_status.kind == TARGET_WAITKIND_STOPPED)
1729 prepare_resume_reply (own_buf, last_ptid, &last_status);
1731 /* In non-stop, sending a resume reply doesn't set the general
1732 thread, but GDB assumes a vRun sets it (this is so GDB can
1733 query which is the main thread of the new inferior. */
1735 general_thread = last_ptid;
1741 write_enn (own_buf);
1746 /* Kill process. Return 1 if successful, 0 if failure. */
1748 handle_v_kill (char *own_buf)
1751 char *p = &own_buf[6];
1753 pid = strtol (p, NULL, 16);
1756 if (pid != 0 && kill_inferior (pid) == 0)
1758 last_status.kind = TARGET_WAITKIND_SIGNALLED;
1759 last_status.value.sig = TARGET_SIGNAL_KILL;
1760 last_ptid = pid_to_ptid (pid);
1761 discard_queued_stop_replies (pid);
1767 write_enn (own_buf);
1772 /* Handle a 'vStopped' packet. */
1774 handle_v_stopped (char *own_buf)
1776 /* If we're waiting for GDB to acknowledge a pending stop reply,
1777 consider that done. */
1780 struct vstop_notif *head;
1783 fprintf (stderr, "vStopped: acking %s\n",
1784 target_pid_to_str (notif_queue->ptid));
1787 notif_queue = notif_queue->next;
1791 /* Push another stop reply, or if there are no more left, an OK. */
1792 send_next_stop_reply (own_buf);
1795 /* Handle all of the extended 'v' packets. */
1797 handle_v_requests (char *own_buf, int packet_len, int *new_packet_len)
1799 if (!disable_packet_vCont)
1801 if (strncmp (own_buf, "vCont;", 6) == 0)
1803 require_running (own_buf);
1804 handle_v_cont (own_buf);
1808 if (strncmp (own_buf, "vCont?", 6) == 0)
1810 strcpy (own_buf, "vCont;c;C;s;S;t");
1815 if (strncmp (own_buf, "vFile:", 6) == 0
1816 && handle_vFile (own_buf, packet_len, new_packet_len))
1819 if (strncmp (own_buf, "vAttach;", 8) == 0)
1821 if (!multi_process && target_running ())
1823 fprintf (stderr, "Already debugging a process\n");
1824 write_enn (own_buf);
1827 handle_v_attach (own_buf);
1831 if (strncmp (own_buf, "vRun;", 5) == 0)
1833 if (!multi_process && target_running ())
1835 fprintf (stderr, "Already debugging a process\n");
1836 write_enn (own_buf);
1839 handle_v_run (own_buf);
1843 if (strncmp (own_buf, "vKill;", 6) == 0)
1845 if (!target_running ())
1847 fprintf (stderr, "No process to kill\n");
1848 write_enn (own_buf);
1851 handle_v_kill (own_buf);
1855 if (strncmp (own_buf, "vStopped", 8) == 0)
1857 handle_v_stopped (own_buf);
1861 /* Otherwise we didn't know what packet it was. Say we didn't
1867 /* Resume inferior and wait for another event. In non-stop mode,
1868 don't really wait here, but return immediatelly to the event
1871 myresume (char *own_buf, int step, int sig)
1873 struct thread_resume resume_info[2];
1875 int valid_cont_thread;
1877 set_desired_inferior (0);
1879 valid_cont_thread = (!ptid_equal (cont_thread, null_ptid)
1880 && !ptid_equal (cont_thread, minus_one_ptid));
1882 if (step || sig || valid_cont_thread)
1884 resume_info[0].thread
1885 = ((struct inferior_list_entry *) current_inferior)->id;
1887 resume_info[0].kind = resume_step;
1889 resume_info[0].kind = resume_continue;
1890 resume_info[0].sig = sig;
1894 if (!valid_cont_thread)
1896 resume_info[n].thread = minus_one_ptid;
1897 resume_info[n].kind = resume_continue;
1898 resume_info[n].sig = 0;
1905 (*the_target->resume) (resume_info, n);
1911 last_ptid = mywait (minus_one_ptid, &last_status, 0, 1);
1912 prepare_resume_reply (own_buf, last_ptid, &last_status);
1913 disable_async_io ();
1917 /* Callback for for_each_inferior. Make a new stop reply for each
1921 queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg)
1923 int pid = * (int *) arg;
1926 || ptid_get_pid (entry->id) == pid)
1928 struct target_waitstatus status;
1930 status.kind = TARGET_WAITKIND_STOPPED;
1931 status.value.sig = TARGET_SIGNAL_TRAP;
1933 /* Pass the last stop reply back to GDB, but don't notify. */
1934 queue_stop_reply (entry->id, &status);
1940 /* Status handler for the '?' packet. */
1943 handle_status (char *own_buf)
1945 struct target_waitstatus status;
1946 status.kind = TARGET_WAITKIND_STOPPED;
1947 status.value.sig = TARGET_SIGNAL_TRAP;
1949 /* In non-stop mode, we must send a stop reply for each stopped
1950 thread. In all-stop mode, just send one for the first stopped
1956 discard_queued_stop_replies (pid);
1957 find_inferior (&all_threads, queue_stop_reply_callback, &pid);
1959 /* The first is sent immediatly. OK is sent if there is no
1960 stopped thread, which is the same handling of the vStopped
1961 packet (by design). */
1962 send_next_stop_reply (own_buf);
1966 if (all_threads.head)
1967 prepare_resume_reply (own_buf,
1968 all_threads.head->id, &status);
1970 strcpy (own_buf, "W00");
1975 gdbserver_version (void)
1977 printf ("GNU gdbserver %s%s\n"
1978 "Copyright (C) 2010 Free Software Foundation, Inc.\n"
1979 "gdbserver is free software, covered by the GNU General Public License.\n"
1980 "This gdbserver was configured as \"%s\"\n",
1981 PKGVERSION, version, host_name);
1985 gdbserver_usage (FILE *stream)
1987 fprintf (stream, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
1988 "\tgdbserver [OPTIONS] --attach COMM PID\n"
1989 "\tgdbserver [OPTIONS] --multi COMM\n"
1991 "COMM may either be a tty device (for serial debugging), or \n"
1992 "HOST:PORT to listen for a TCP connection.\n"
1995 " --debug Enable general debugging output.\n"
1996 " --remote-debug Enable remote protocol debugging output.\n"
1997 " --version Display version information and exit.\n"
1998 " --wrapper WRAPPER -- Run WRAPPER to start new programs.\n");
1999 if (REPORT_BUGS_TO[0] && stream == stdout)
2000 fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
2004 gdbserver_show_disableable (FILE *stream)
2006 fprintf (stream, "Disableable packets:\n"
2007 " vCont \tAll vCont packets\n"
2008 " qC \tQuerying the current thread\n"
2009 " qfThreadInfo\tThread listing\n"
2010 " Tthread \tPassing the thread specifier in the T stop reply packet\n"
2011 " threads \tAll of the above\n");
2015 #undef require_running
2016 #define require_running(BUF) \
2017 if (!target_running ()) \
2024 first_thread_of (struct inferior_list_entry *entry, void *args)
2026 int pid = * (int *) args;
2028 if (ptid_get_pid (entry->id) == pid)
2035 kill_inferior_callback (struct inferior_list_entry *entry)
2037 struct process_info *process = (struct process_info *) entry;
2038 int pid = ptid_get_pid (process->head.id);
2040 kill_inferior (pid);
2041 discard_queued_stop_replies (pid);
2044 /* Callback for for_each_inferior to detach or kill the inferior,
2045 depending on whether we attached to it or not.
2046 We inform the user whether we're detaching or killing the process
2047 as this is only called when gdbserver is about to exit. */
2050 detach_or_kill_inferior_callback (struct inferior_list_entry *entry)
2052 struct process_info *process = (struct process_info *) entry;
2053 int pid = ptid_get_pid (process->head.id);
2055 if (process->attached)
2056 detach_inferior (pid);
2058 kill_inferior (pid);
2060 discard_queued_stop_replies (pid);
2063 /* for_each_inferior callback for detach_or_kill_for_exit to print
2064 the pids of started inferiors. */
2067 print_started_pid (struct inferior_list_entry *entry)
2069 struct process_info *process = (struct process_info *) entry;
2071 if (! process->attached)
2073 int pid = ptid_get_pid (process->head.id);
2074 fprintf (stderr, " %d", pid);
2078 /* for_each_inferior callback for detach_or_kill_for_exit to print
2079 the pids of attached inferiors. */
2082 print_attached_pid (struct inferior_list_entry *entry)
2084 struct process_info *process = (struct process_info *) entry;
2086 if (process->attached)
2088 int pid = ptid_get_pid (process->head.id);
2089 fprintf (stderr, " %d", pid);
2093 /* Call this when exiting gdbserver with possible inferiors that need
2094 to be killed or detached from. */
2097 detach_or_kill_for_exit (void)
2099 /* First print a list of the inferiors we will be killing/detaching.
2100 This is to assist the user, for example, in case the inferior unexpectedly
2101 dies after we exit: did we screw up or did the inferior exit on its own?
2102 Having this info will save some head-scratching. */
2104 if (have_started_inferiors_p ())
2106 fprintf (stderr, "Killing process(es):");
2107 for_each_inferior (&all_processes, print_started_pid);
2108 fprintf (stderr, "\n");
2110 if (have_attached_inferiors_p ())
2112 fprintf (stderr, "Detaching process(es):");
2113 for_each_inferior (&all_processes, print_attached_pid);
2114 fprintf (stderr, "\n");
2117 /* Now we can kill or detach the inferiors. */
2119 for_each_inferior (&all_processes, detach_or_kill_inferior_callback);
2123 join_inferiors_callback (struct inferior_list_entry *entry)
2125 struct process_info *process = (struct process_info *) entry;
2127 /* If we are attached, then we can exit. Otherwise, we need to hang
2128 around doing nothing, until the child is gone. */
2129 if (!process->attached)
2130 join_inferior (ptid_get_pid (process->head.id));
2134 main (int argc, char *argv[])
2138 char *arg_end, *port;
2139 char **next_arg = &argv[1];
2144 while (*next_arg != NULL && **next_arg == '-')
2146 if (strcmp (*next_arg, "--version") == 0)
2148 gdbserver_version ();
2151 else if (strcmp (*next_arg, "--help") == 0)
2153 gdbserver_usage (stdout);
2156 else if (strcmp (*next_arg, "--attach") == 0)
2158 else if (strcmp (*next_arg, "--multi") == 0)
2160 else if (strcmp (*next_arg, "--wrapper") == 0)
2164 wrapper_argv = next_arg;
2165 while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
2168 if (next_arg == wrapper_argv || *next_arg == NULL)
2170 gdbserver_usage (stderr);
2174 /* Consume the "--". */
2177 else if (strcmp (*next_arg, "--debug") == 0)
2179 else if (strcmp (*next_arg, "--remote-debug") == 0)
2181 else if (strcmp (*next_arg, "--disable-packet") == 0)
2183 gdbserver_show_disableable (stdout);
2186 else if (strncmp (*next_arg,
2187 "--disable-packet=",
2188 sizeof ("--disable-packet=") - 1) == 0)
2190 char *packets, *tok;
2192 packets = *next_arg += sizeof ("--disable-packet=") - 1;
2193 for (tok = strtok (packets, ",");
2195 tok = strtok (NULL, ","))
2197 if (strcmp ("vCont", tok) == 0)
2198 disable_packet_vCont = 1;
2199 else if (strcmp ("Tthread", tok) == 0)
2200 disable_packet_Tthread = 1;
2201 else if (strcmp ("qC", tok) == 0)
2202 disable_packet_qC = 1;
2203 else if (strcmp ("qfThreadInfo", tok) == 0)
2204 disable_packet_qfThreadInfo = 1;
2205 else if (strcmp ("threads", tok) == 0)
2207 disable_packet_vCont = 1;
2208 disable_packet_Tthread = 1;
2209 disable_packet_qC = 1;
2210 disable_packet_qfThreadInfo = 1;
2214 fprintf (stderr, "Don't know how to disable \"%s\".\n\n",
2216 gdbserver_show_disableable (stderr);
2223 fprintf (stderr, "Unknown argument: %s\n", *next_arg);
2231 if (setjmp (toplevel))
2233 fprintf (stderr, "Exiting\n");
2239 if (port == NULL || (!attach && !multi_mode && *next_arg == NULL))
2241 gdbserver_usage (stderr);
2248 /* --attach used to come after PORT, so allow it there for
2250 if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
2257 && (*next_arg == NULL
2258 || (*next_arg)[0] == '\0'
2259 || (pid = strtoul (*next_arg, &arg_end, 0)) == 0
2261 || next_arg[1] != NULL))
2266 gdbserver_usage (stderr);
2270 initialize_inferiors ();
2271 initialize_async_io ();
2274 own_buf = xmalloc (PBUFSIZ + 1);
2275 mem_buf = xmalloc (PBUFSIZ);
2277 if (pid == 0 && *next_arg != NULL)
2281 n = argc - (next_arg - argv);
2282 program_argv = xmalloc (sizeof (char *) * (n + 1));
2283 for (i = 0; i < n; i++)
2284 program_argv[i] = xstrdup (next_arg[i]);
2285 program_argv[i] = NULL;
2287 /* Wait till we are at first instruction in program. */
2288 start_inferior (program_argv);
2290 /* We are now (hopefully) stopped at the first instruction of
2291 the target process. This assumes that the target process was
2292 successfully created. */
2296 if (attach_inferior (pid) == -1)
2297 error ("Attaching not supported on this target");
2299 /* Otherwise succeeded. */
2303 last_status.kind = TARGET_WAITKIND_EXITED;
2304 last_status.value.integer = 0;
2305 last_ptid = minus_one_ptid;
2308 /* Don't report shared library events on the initial connection,
2309 even if some libraries are preloaded. Avoids the "stopped by
2310 shared library event" notice on gdb side. */
2313 if (setjmp (toplevel))
2315 detach_or_kill_for_exit ();
2319 if (last_status.kind == TARGET_WAITKIND_EXITED
2320 || last_status.kind == TARGET_WAITKIND_SIGNALLED)
2325 if (!was_running && !multi_mode)
2327 fprintf (stderr, "No program to debug. GDBserver exiting.\n");
2339 if (setjmp (toplevel) != 0)
2341 /* An error occurred. */
2342 if (response_needed)
2344 write_enn (own_buf);
2349 /* Wait for events. This will return when all event sources are
2350 removed from the event loop. */
2351 start_event_loop ();
2353 /* If an exit was requested (using the "monitor exit" command),
2354 terminate now. The only other way to get here is for
2355 getpkt to fail; close the connection and reopen it at the
2360 detach_or_kill_for_exit ();
2364 fprintf (stderr, "Remote side has terminated connection. "
2365 "GDBserver will reopen the connection.\n");
2369 /* Event loop callback that handles a serial event. The first byte in
2370 the serial buffer gets us here. We expect characters to arrive at
2371 a brisk pace, so we read the rest of the packet with a blocking
2375 process_serial_event (void)
2385 int new_packet_len = -1;
2387 /* Used to decide when gdbserver should exit in
2388 multi-mode/remote. */
2389 static int have_ran = 0;
2392 have_ran = target_running ();
2394 disable_async_io ();
2396 response_needed = 0;
2397 packet_len = getpkt (own_buf);
2398 if (packet_len <= 0)
2404 response_needed = 1;
2411 handle_query (own_buf, packet_len, &new_packet_len);
2414 handle_general_set (own_buf);
2417 require_running (own_buf);
2422 pid = strtol (&own_buf[i], NULL, 16);
2426 ptid_get_pid (((struct inferior_list_entry *) current_inferior)->id);
2428 fprintf (stderr, "Detaching from process %d\n", pid);
2429 if (detach_inferior (pid) != 0)
2430 write_enn (own_buf);
2433 discard_queued_stop_replies (pid);
2436 if (extended_protocol)
2438 /* Treat this like a normal program exit. */
2439 last_status.kind = TARGET_WAITKIND_EXITED;
2440 last_status.value.integer = 0;
2441 last_ptid = pid_to_ptid (pid);
2443 current_inferior = NULL;
2450 /* If we are attached, then we can exit. Otherwise, we
2451 need to hang around doing nothing, until the child is
2453 for_each_inferior (&all_processes,
2454 join_inferiors_callback);
2460 extended_protocol = 1;
2464 handle_status (own_buf);
2467 if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
2469 ptid_t gdb_id, thread_id;
2472 require_running (own_buf);
2474 gdb_id = read_ptid (&own_buf[2], NULL);
2476 pid = ptid_get_pid (gdb_id);
2478 if (ptid_equal (gdb_id, null_ptid)
2479 || ptid_equal (gdb_id, minus_one_ptid))
2480 thread_id = null_ptid;
2482 && ptid_equal (pid_to_ptid (pid),
2485 struct thread_info *thread =
2486 (struct thread_info *) find_inferior (&all_threads,
2491 write_enn (own_buf);
2495 thread_id = ((struct inferior_list_entry *)thread)->id;
2499 thread_id = gdb_id_to_thread_id (gdb_id);
2500 if (ptid_equal (thread_id, null_ptid))
2502 write_enn (own_buf);
2507 if (own_buf[1] == 'g')
2509 if (ptid_equal (thread_id, null_ptid))
2511 /* GDB is telling us to choose any thread. Check if
2512 the currently selected thread is still valid. If
2513 it is not, select the first available. */
2514 struct thread_info *thread =
2515 (struct thread_info *) find_inferior_id (&all_threads,
2518 thread_id = all_threads.head->id;
2521 general_thread = thread_id;
2522 set_desired_inferior (1);
2524 else if (own_buf[1] == 'c')
2525 cont_thread = thread_id;
2526 else if (own_buf[1] == 's')
2527 step_thread = thread_id;
2533 /* Silently ignore it so that gdb can extend the protocol
2534 without compatibility headaches. */
2540 struct regcache *regcache;
2542 require_running (own_buf);
2543 set_desired_inferior (1);
2544 regcache = get_thread_regcache (current_inferior, 1);
2545 registers_to_string (regcache, own_buf);
2550 struct regcache *regcache;
2552 require_running (own_buf);
2553 set_desired_inferior (1);
2554 regcache = get_thread_regcache (current_inferior, 1);
2555 registers_from_string (regcache, &own_buf[1]);
2560 require_running (own_buf);
2561 decode_m_packet (&own_buf[1], &mem_addr, &len);
2562 if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
2563 convert_int_to_ascii (mem_buf, own_buf, len);
2565 write_enn (own_buf);
2568 require_running (own_buf);
2569 decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
2570 if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
2573 write_enn (own_buf);
2576 require_running (own_buf);
2577 if (decode_X_packet (&own_buf[1], packet_len - 1,
2578 &mem_addr, &len, mem_buf) < 0
2579 || write_inferior_memory (mem_addr, mem_buf, len) != 0)
2580 write_enn (own_buf);
2585 require_running (own_buf);
2586 convert_ascii_to_int (own_buf + 1, &sig, 1);
2587 if (target_signal_to_host_p (sig))
2588 signal = target_signal_to_host (sig);
2591 myresume (own_buf, 0, signal);
2594 require_running (own_buf);
2595 convert_ascii_to_int (own_buf + 1, &sig, 1);
2596 if (target_signal_to_host_p (sig))
2597 signal = target_signal_to_host (sig);
2600 myresume (own_buf, 1, signal);
2603 require_running (own_buf);
2605 myresume (own_buf, 0, signal);
2608 require_running (own_buf);
2610 myresume (own_buf, 1, signal);
2612 case 'Z': /* insert_ ... */
2614 case 'z': /* remove_ ... */
2618 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
2619 int len = strtol (lenptr + 1, &dataptr, 16);
2620 char type = own_buf[1];
2622 const int insert = ch == 'Z';
2624 /* Default to unrecognized/unsupported. */
2628 case '0': /* software-breakpoint */
2629 case '1': /* hardware-breakpoint */
2630 case '2': /* write watchpoint */
2631 case '3': /* read watchpoint */
2632 case '4': /* access watchpoint */
2633 require_running (own_buf);
2634 if (insert && the_target->insert_point != NULL)
2635 res = (*the_target->insert_point) (type, addr, len);
2636 else if (!insert && the_target->remove_point != NULL)
2637 res = (*the_target->remove_point) (type, addr, len);
2649 write_enn (own_buf);
2653 response_needed = 0;
2654 if (!target_running ())
2655 /* The packet we received doesn't make sense - but we can't
2656 reply to it, either. */
2659 fprintf (stderr, "Killing all inferiors\n");
2660 for_each_inferior (&all_processes, kill_inferior_callback);
2662 /* When using the extended protocol, we wait with no program
2663 running. The traditional protocol will exit instead. */
2664 if (extended_protocol)
2666 last_status.kind = TARGET_WAITKIND_EXITED;
2667 last_status.value.sig = TARGET_SIGNAL_KILL;
2677 ptid_t gdb_id, thread_id;
2679 require_running (own_buf);
2681 gdb_id = read_ptid (&own_buf[1], NULL);
2682 thread_id = gdb_id_to_thread_id (gdb_id);
2683 if (ptid_equal (thread_id, null_ptid))
2685 write_enn (own_buf);
2689 if (mythread_alive (thread_id))
2692 write_enn (own_buf);
2696 response_needed = 0;
2698 /* Restarting the inferior is only supported in the extended
2700 if (extended_protocol)
2702 if (target_running ())
2703 for_each_inferior (&all_processes,
2704 kill_inferior_callback);
2705 fprintf (stderr, "GDBserver restarting\n");
2707 /* Wait till we are at 1st instruction in prog. */
2708 if (program_argv != NULL)
2709 start_inferior (program_argv);
2712 last_status.kind = TARGET_WAITKIND_EXITED;
2713 last_status.value.sig = TARGET_SIGNAL_KILL;
2719 /* It is a request we don't understand. Respond with an
2720 empty packet so that gdb knows that we don't support this
2726 /* Extended (long) request. */
2727 handle_v_requests (own_buf, packet_len, &new_packet_len);
2731 /* It is a request we don't understand. Respond with an empty
2732 packet so that gdb knows that we don't support this
2738 if (new_packet_len != -1)
2739 putpkt_binary (own_buf, new_packet_len);
2743 response_needed = 0;
2745 if (!extended_protocol && have_ran && !target_running ())
2747 /* In non-stop, defer exiting until GDB had a chance to query
2748 the whole vStopped list (until it gets an OK). */
2751 fprintf (stderr, "GDBserver exiting\n");
2758 /* Event-loop callback for serial events. */
2761 handle_serial_event (int err, gdb_client_data client_data)
2764 fprintf (stderr, "handling possible serial event\n");
2766 /* Really handle it. */
2767 process_serial_event ();
2769 /* Be sure to not change the selected inferior behind GDB's back.
2770 Important in the non-stop mode asynchronous protocol. */
2771 set_desired_inferior (1);
2774 /* Event-loop callback for target events. */
2777 handle_target_event (int err, gdb_client_data client_data)
2780 fprintf (stderr, "handling possible target event\n");
2782 last_ptid = mywait (minus_one_ptid, &last_status,
2785 if (last_status.kind != TARGET_WAITKIND_IGNORE)
2787 /* Something interesting. Tell GDB about it. */
2788 push_event (last_ptid, &last_status);
2791 /* Be sure to not change the selected inferior behind GDB's back.
2792 Important in the non-stop mode asynchronous protocol. */
2793 set_desired_inferior (1);