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 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/>. */
32 unsigned long cont_thread;
33 unsigned long general_thread;
34 unsigned long step_thread;
35 unsigned long thread_from_wait;
36 unsigned long old_thread_from_wait;
39 static int extended_protocol;
41 static int response_needed;
42 static int exit_requested;
44 static char **program_argv, **wrapper_argv;
46 /* Enable miscellaneous debugging output. The name is historical - it
47 was originally used to debug LinuxThreads support. */
50 int pass_signals[TARGET_SIGNAL_LAST];
54 const char *gdbserver_xmltarget;
56 /* The PID of the originally created or attached inferior. Used to
57 send signals to the process when GDB sends us an asynchronous interrupt
58 (user hitting Control-C in the client), and to wait for the child to exit
59 when no longer debugging it. */
61 unsigned long signal_pid;
64 /* A file descriptor for the controlling terminal. */
67 /* TERMINAL_FD's original foreground group. */
68 pid_t old_foreground_pgrp;
70 /* Hand back terminal ownership to the original foreground group. */
73 restore_old_foreground_pgrp (void)
75 tcsetpgrp (terminal_fd, old_foreground_pgrp);
82 return all_threads.head != NULL;
86 start_inferior (char **argv, char *statusptr)
88 char **new_argv = argv;
91 if (wrapper_argv != NULL)
95 for (i = 0; wrapper_argv[i] != NULL; i++)
97 for (i = 0; argv[i] != NULL; i++)
99 new_argv = alloca (sizeof (char *) * count);
101 for (i = 0; wrapper_argv[i] != NULL; i++)
102 new_argv[count++] = wrapper_argv[i];
103 for (i = 0; argv[i] != NULL; i++)
104 new_argv[count++] = argv[i];
105 new_argv[count] = NULL;
109 signal (SIGTTOU, SIG_DFL);
110 signal (SIGTTIN, SIG_DFL);
113 signal_pid = create_inferior (new_argv[0], new_argv);
115 /* FIXME: we don't actually know at this point that the create
116 actually succeeded. We won't know that until we wait. */
117 fprintf (stderr, "Process %s created; pid = %ld\n", argv[0],
122 signal (SIGTTOU, SIG_IGN);
123 signal (SIGTTIN, SIG_IGN);
124 terminal_fd = fileno (stderr);
125 old_foreground_pgrp = tcgetpgrp (terminal_fd);
126 tcsetpgrp (terminal_fd, signal_pid);
127 atexit (restore_old_foreground_pgrp);
130 if (wrapper_argv != NULL)
132 struct thread_resume resume_info;
135 resume_info.thread = -1;
136 resume_info.step = 0;
138 resume_info.leave_stopped = 0;
140 sig = mywait (statusptr, 0);
141 if (*statusptr != 'T')
146 (*the_target->resume) (&resume_info);
148 sig = mywait (statusptr, 0);
149 if (*statusptr != 'T')
152 while (sig != TARGET_SIGNAL_TRAP);
157 /* Wait till we are at 1st instruction in program, return signal
158 number (assuming success). */
159 return mywait (statusptr, 0);
163 attach_inferior (int pid, char *statusptr, int *sigptr)
165 /* myattach should return -1 if attaching is unsupported,
166 0 if it succeeded, and call error() otherwise. */
168 if (myattach (pid) != 0)
173 fprintf (stderr, "Attached; pid = %d\n", pid);
176 /* FIXME - It may be that we should get the SIGNAL_PID from the
177 attach function, so that it can be the main thread instead of
178 whichever we were told to attach to. */
181 *sigptr = mywait (statusptr, 0);
183 /* GDB knows to ignore the first SIGSTOP after attaching to a running
184 process using the "attach" command, but this is different; it's
185 just using "target remote". Pretend it's just starting up. */
186 if (*statusptr == 'T' && *sigptr == TARGET_SIGNAL_STOP)
187 *sigptr = TARGET_SIGNAL_TRAP;
192 extern int remote_debug;
194 /* Decode a qXfer read request. Return 0 if everything looks OK,
198 decode_xfer_read (char *buf, char **annex, CORE_ADDR *ofs, unsigned int *len)
200 /* Extract and NUL-terminate the annex. */
202 while (*buf && *buf != ':')
208 /* After the read marker and annex, qXfer looks like a
209 traditional 'm' packet. */
210 decode_m_packet (buf, ofs, len);
215 /* Write the response to a successful qXfer read. Returns the
216 length of the (binary) data stored in BUF, corresponding
217 to as much of DATA/LEN as we could fit. IS_MORE controls
218 the first character of the response. */
220 write_qxfer_response (char *buf, const void *data, int len, int is_more)
229 return remote_escape_output (data, len, (unsigned char *) buf + 1, &out_len,
233 /* Handle all of the extended 'Q' packets. */
235 handle_general_set (char *own_buf)
237 if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0)
239 int numsigs = (int) TARGET_SIGNAL_LAST, i;
240 const char *p = own_buf + strlen ("QPassSignals:");
243 p = decode_address_to_semicolon (&cursig, p);
244 for (i = 0; i < numsigs; i++)
250 /* Keep looping, to clear the remaining signals. */
253 p = decode_address_to_semicolon (&cursig, p);
258 strcpy (own_buf, "OK");
262 /* Otherwise we didn't know what packet it was. Say we didn't
268 get_features_xml (const char *annex)
270 /* gdbserver_xmltarget defines what to return when looking
271 for the "target.xml" file. Its contents can either be
272 verbatim XML code (prefixed with a '@') or else the name
273 of the actual XML file to be used in place of "target.xml".
275 This variable is set up from the auto-generated
276 init_registers_... routine for the current target. */
278 if (gdbserver_xmltarget
279 && strcmp (annex, "target.xml") == 0)
281 if (*gdbserver_xmltarget == '@')
282 return gdbserver_xmltarget + 1;
284 annex = gdbserver_xmltarget;
289 extern const char *const xml_builtin[][2];
292 /* Look for the annex. */
293 for (i = 0; xml_builtin[i][0] != NULL; i++)
294 if (strcmp (annex, xml_builtin[i][0]) == 0)
297 if (xml_builtin[i][0] != NULL)
298 return xml_builtin[i][1];
306 monitor_show_help (void)
308 monitor_output ("The following monitor commands are supported:\n");
309 monitor_output (" set debug <0|1>\n");
310 monitor_output (" Enable general debugging messages\n");
311 monitor_output (" set remote-debug <0|1>\n");
312 monitor_output (" Enable remote protocol debugging messages\n");
313 monitor_output (" exit\n");
314 monitor_output (" Quit GDBserver\n");
317 /* Subroutine of handle_search_memory to simplify it. */
320 handle_search_memory_1 (CORE_ADDR start_addr, CORE_ADDR search_space_len,
321 gdb_byte *pattern, unsigned pattern_len,
322 gdb_byte *search_buf,
323 unsigned chunk_size, unsigned search_buf_size,
324 CORE_ADDR *found_addrp)
326 /* Prime the search buffer. */
328 if (read_inferior_memory (start_addr, search_buf, search_buf_size) != 0)
330 warning ("Unable to access target memory at 0x%lx, halting search.",
335 /* Perform the search.
337 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
338 When we've scanned N bytes we copy the trailing bytes to the start and
339 read in another N bytes. */
341 while (search_space_len >= pattern_len)
344 unsigned nr_search_bytes = (search_space_len < search_buf_size
348 found_ptr = memmem (search_buf, nr_search_bytes, pattern, pattern_len);
350 if (found_ptr != NULL)
352 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
353 *found_addrp = found_addr;
357 /* Not found in this chunk, skip to next chunk. */
359 /* Don't let search_space_len wrap here, it's unsigned. */
360 if (search_space_len >= chunk_size)
361 search_space_len -= chunk_size;
363 search_space_len = 0;
365 if (search_space_len >= pattern_len)
367 unsigned keep_len = search_buf_size - chunk_size;
368 CORE_ADDR read_addr = start_addr + keep_len;
371 /* Copy the trailing part of the previous iteration to the front
372 of the buffer for the next iteration. */
373 memcpy (search_buf, search_buf + chunk_size, keep_len);
375 nr_to_read = (search_space_len - keep_len < chunk_size
376 ? search_space_len - keep_len
379 if (read_inferior_memory (read_addr, search_buf + keep_len,
382 warning ("Unable to access target memory at 0x%lx, halting search.",
387 start_addr += chunk_size;
396 /* Handle qSearch:memory packets. */
399 handle_search_memory (char *own_buf, int packet_len)
401 CORE_ADDR start_addr;
402 CORE_ADDR search_space_len;
404 unsigned int pattern_len;
405 /* NOTE: also defined in find.c testcase. */
406 #define SEARCH_CHUNK_SIZE 16000
407 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
408 /* Buffer to hold memory contents for searching. */
409 gdb_byte *search_buf;
410 unsigned search_buf_size;
412 CORE_ADDR found_addr;
413 int cmd_name_len = sizeof ("qSearch:memory:") - 1;
415 pattern = malloc (packet_len);
418 error ("Unable to allocate memory to perform the search");
419 strcpy (own_buf, "E00");
422 if (decode_search_memory_packet (own_buf + cmd_name_len,
423 packet_len - cmd_name_len,
424 &start_addr, &search_space_len,
425 pattern, &pattern_len) < 0)
428 error ("Error in parsing qSearch:memory packet");
429 strcpy (own_buf, "E00");
433 search_buf_size = chunk_size + pattern_len - 1;
435 /* No point in trying to allocate a buffer larger than the search space. */
436 if (search_space_len < search_buf_size)
437 search_buf_size = search_space_len;
439 search_buf = malloc (search_buf_size);
440 if (search_buf == NULL)
443 error ("Unable to allocate memory to perform the search");
444 strcpy (own_buf, "E00");
448 found = handle_search_memory_1 (start_addr, search_space_len,
449 pattern, pattern_len,
450 search_buf, chunk_size, search_buf_size,
454 sprintf (own_buf, "1,%lx", (long) found_addr);
456 strcpy (own_buf, "0");
458 strcpy (own_buf, "E00");
464 #define require_running(BUF) \
465 if (!target_running ()) \
471 /* Handle all of the extended 'q' packets. */
473 handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
475 static struct inferior_list_entry *thread_ptr;
477 /* Reply the current thread id. */
478 if (strcmp ("qC", own_buf) == 0)
480 require_running (own_buf);
481 thread_ptr = all_threads.head;
482 sprintf (own_buf, "QC%x",
483 thread_to_gdb_id ((struct thread_info *)thread_ptr));
487 if (strcmp ("qSymbol::", own_buf) == 0)
489 if (target_running () && the_target->look_up_symbols != NULL)
490 (*the_target->look_up_symbols) ();
492 strcpy (own_buf, "OK");
496 if (strcmp ("qfThreadInfo", own_buf) == 0)
498 require_running (own_buf);
499 thread_ptr = all_threads.head;
500 sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
501 thread_ptr = thread_ptr->next;
505 if (strcmp ("qsThreadInfo", own_buf) == 0)
507 require_running (own_buf);
508 if (thread_ptr != NULL)
510 sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr));
511 thread_ptr = thread_ptr->next;
516 sprintf (own_buf, "l");
521 if (the_target->read_offsets != NULL
522 && strcmp ("qOffsets", own_buf) == 0)
524 CORE_ADDR text, data;
526 require_running (own_buf);
527 if (the_target->read_offsets (&text, &data))
528 sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX",
529 (long)text, (long)data, (long)data);
536 if (the_target->qxfer_spu != NULL
537 && strncmp ("qXfer:spu:read:", own_buf, 15) == 0)
543 unsigned char *spu_buf;
545 require_running (own_buf);
546 strcpy (own_buf, "E00");
547 if (decode_xfer_read (own_buf + 15, &annex, &ofs, &len) < 0)
549 if (len > PBUFSIZ - 2)
551 spu_buf = malloc (len + 1);
555 n = (*the_target->qxfer_spu) (annex, spu_buf, NULL, ofs, len + 1);
559 *new_packet_len_p = write_qxfer_response
560 (own_buf, spu_buf, len, 1);
562 *new_packet_len_p = write_qxfer_response
563 (own_buf, spu_buf, n, 0);
569 if (the_target->qxfer_spu != NULL
570 && strncmp ("qXfer:spu:write:", own_buf, 16) == 0)
576 unsigned char *spu_buf;
578 require_running (own_buf);
579 strcpy (own_buf, "E00");
580 spu_buf = malloc (packet_len - 15);
583 if (decode_xfer_write (own_buf + 16, packet_len - 16, &annex,
584 &ofs, &len, spu_buf) < 0)
590 n = (*the_target->qxfer_spu)
591 (annex, NULL, (unsigned const char *)spu_buf, ofs, len);
595 sprintf (own_buf, "%x", n);
601 if (the_target->read_auxv != NULL
602 && strncmp ("qXfer:auxv:read:", own_buf, 16) == 0)
610 require_running (own_buf);
612 /* Reject any annex; grab the offset and length. */
613 if (decode_xfer_read (own_buf + 16, &annex, &ofs, &len) < 0
616 strcpy (own_buf, "E00");
620 /* Read one extra byte, as an indicator of whether there is
622 if (len > PBUFSIZ - 2)
624 data = malloc (len + 1);
625 n = (*the_target->read_auxv) (ofs, data, len + 1);
629 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1);
631 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0);
638 if (strncmp ("qXfer:features:read:", own_buf, 20) == 0)
641 unsigned int len, total_len;
642 const char *document;
645 require_running (own_buf);
647 /* Grab the annex, offset, and length. */
648 if (decode_xfer_read (own_buf + 20, &annex, &ofs, &len) < 0)
650 strcpy (own_buf, "E00");
654 /* Now grab the correct annex. */
655 document = get_features_xml (annex);
656 if (document == NULL)
658 strcpy (own_buf, "E00");
662 total_len = strlen (document);
663 if (len > PBUFSIZ - 2)
668 else if (len < total_len - ofs)
669 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
672 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
678 if (strncmp ("qXfer:libraries:read:", own_buf, 21) == 0)
681 unsigned int len, total_len;
683 struct inferior_list_entry *dll_ptr;
686 require_running (own_buf);
688 /* Reject any annex; grab the offset and length. */
689 if (decode_xfer_read (own_buf + 21, &annex, &ofs, &len) < 0
692 strcpy (own_buf, "E00");
696 /* Over-estimate the necessary memory. Assume that every character
697 in the library name must be escaped. */
699 for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
700 total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name);
702 document = malloc (total_len);
703 strcpy (document, "<library-list>\n");
704 p = document + strlen (document);
706 for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next)
708 struct dll_info *dll = (struct dll_info *) dll_ptr;
711 strcpy (p, " <library name=\"");
713 name = xml_escape_text (dll->name);
717 strcpy (p, "\"><segment address=\"");
719 sprintf (p, "0x%lx", (long) dll->base_addr);
721 strcpy (p, "\"/></library>\n");
725 strcpy (p, "</library-list>\n");
727 total_len = strlen (document);
728 if (len > PBUFSIZ - 2)
733 else if (len < total_len - ofs)
734 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
737 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs,
744 /* Protocol features query. */
745 if (strncmp ("qSupported", own_buf, 10) == 0
746 && (own_buf[10] == ':' || own_buf[10] == '\0'))
748 sprintf (own_buf, "PacketSize=%x;QPassSignals+", PBUFSIZ - 1);
750 /* We do not have any hook to indicate whether the target backend
751 supports qXfer:libraries:read, so always report it. */
752 strcat (own_buf, ";qXfer:libraries:read+");
754 if (the_target->read_auxv != NULL)
755 strcat (own_buf, ";qXfer:auxv:read+");
757 if (the_target->qxfer_spu != NULL)
758 strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+");
760 /* We always report qXfer:features:read, as targets may
761 install XML files on a subsequent call to arch_setup.
762 If we reported to GDB on startup that we don't support
763 qXfer:feature:read at all, we will never be re-queried. */
764 strcat (own_buf, ";qXfer:features:read+");
769 /* Thread-local storage support. */
770 if (the_target->get_tls_address != NULL
771 && strncmp ("qGetTLSAddr:", own_buf, 12) == 0)
773 char *p = own_buf + 12;
774 CORE_ADDR parts[3], address = 0;
777 require_running (own_buf);
779 for (i = 0; i < 3; i++)
787 p2 = strchr (p, ',');
799 decode_address (&parts[i], p, len);
803 if (p != NULL || i < 3)
807 struct thread_info *thread = gdb_id_to_thread (parts[0]);
812 err = the_target->get_tls_address (thread, parts[1], parts[2],
818 sprintf (own_buf, "%llx", address);
827 /* Otherwise, pretend we do not understand this packet. */
830 /* Handle "monitor" commands. */
831 if (strncmp ("qRcmd,", own_buf, 6) == 0)
833 char *mon = malloc (PBUFSIZ);
834 int len = strlen (own_buf + 6);
836 if ((len % 2) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2)
846 if (strcmp (mon, "set debug 1") == 0)
849 monitor_output ("Debug output enabled.\n");
851 else if (strcmp (mon, "set debug 0") == 0)
854 monitor_output ("Debug output disabled.\n");
856 else if (strcmp (mon, "set remote-debug 1") == 0)
859 monitor_output ("Protocol debug output enabled.\n");
861 else if (strcmp (mon, "set remote-debug 0") == 0)
864 monitor_output ("Protocol debug output disabled.\n");
866 else if (strcmp (mon, "help") == 0)
867 monitor_show_help ();
868 else if (strcmp (mon, "exit") == 0)
872 monitor_output ("Unknown monitor command.\n\n");
873 monitor_show_help ();
881 if (strncmp ("qSearch:memory:", own_buf, sizeof ("qSearch:memory:") - 1) == 0)
883 require_running (own_buf);
884 handle_search_memory (own_buf, packet_len);
888 /* Otherwise we didn't know what packet it was. Say we didn't
893 /* Parse vCont packets. */
895 handle_v_cont (char *own_buf, char *status, int *signal)
899 struct thread_resume *resume_info, default_action;
901 /* Count the number of semicolons in the packet. There should be one
910 /* Allocate room for one extra action, for the default remain-stopped
911 behavior; if no default action is in the list, we'll need the extra
913 resume_info = malloc ((n + 1) * sizeof (resume_info[0]));
915 default_action.thread = -1;
916 default_action.leave_stopped = 1;
917 default_action.step = 0;
918 default_action.sig = 0;
926 resume_info[i].leave_stopped = 0;
928 if (p[0] == 's' || p[0] == 'S')
929 resume_info[i].step = 1;
930 else if (p[0] == 'c' || p[0] == 'C')
931 resume_info[i].step = 0;
935 if (p[0] == 'S' || p[0] == 'C')
938 sig = strtol (p + 1, &q, 16);
943 if (!target_signal_to_host_p (sig))
945 resume_info[i].sig = target_signal_to_host (sig);
949 resume_info[i].sig = 0;
955 resume_info[i].thread = -1;
956 default_action = resume_info[i];
958 /* Note: we don't increment i here, we'll overwrite this entry
959 the next time through. */
961 else if (p[0] == ':')
963 unsigned int gdb_id = strtoul (p + 1, &q, 16);
964 unsigned long thread_id;
969 if (p[0] != ';' && p[0] != 0)
972 thread_id = gdb_id_to_thread_id (gdb_id);
974 resume_info[i].thread = thread_id;
982 resume_info[i] = default_action;
984 /* Still used in occasional places in the backend. */
985 if (n == 1 && resume_info[0].thread != -1)
986 cont_thread = resume_info[0].thread;
989 set_desired_inferior (0);
992 (*the_target->resume) (resume_info);
996 *signal = mywait (status, 1);
997 prepare_resume_reply (own_buf, *status, *signal);
1002 write_enn (own_buf);
1007 /* Attach to a new program. Return 1 if successful, 0 if failure. */
1009 handle_v_attach (char *own_buf, char *status, int *signal)
1013 pid = strtol (own_buf + 8, NULL, 16);
1014 if (pid != 0 && attach_inferior (pid, status, signal) == 0)
1016 prepare_resume_reply (own_buf, *status, *signal);
1021 write_enn (own_buf);
1026 /* Run a new program. Return 1 if successful, 0 if failure. */
1028 handle_v_run (char *own_buf, char *status, int *signal)
1030 char *p, **pp, *next_p, **new_argv;
1034 for (p = own_buf + strlen ("vRun;"); p && *p; p = strchr (p, ';'))
1040 new_argv = malloc ((new_argc + 2) * sizeof (char *));
1042 for (p = own_buf + strlen ("vRun;"); *p; p = next_p)
1044 next_p = strchr (p, ';');
1046 next_p = p + strlen (p);
1048 if (i == 0 && p == next_p)
1052 new_argv[i] = malloc (1 + (next_p - p) / 2);
1053 unhexify (new_argv[i], p, (next_p - p) / 2);
1054 new_argv[i][(next_p - p) / 2] = '\0';
1063 if (new_argv[0] == NULL)
1065 if (program_argv == NULL)
1067 write_enn (own_buf);
1071 new_argv[0] = strdup (program_argv[0]);
1074 /* Free the old argv. */
1077 for (pp = program_argv; *pp != NULL; pp++)
1079 free (program_argv);
1081 program_argv = new_argv;
1083 *signal = start_inferior (program_argv, status);
1086 prepare_resume_reply (own_buf, *status, *signal);
1091 write_enn (own_buf);
1096 /* Handle all of the extended 'v' packets. */
1098 handle_v_requests (char *own_buf, char *status, int *signal,
1099 int packet_len, int *new_packet_len)
1101 if (strncmp (own_buf, "vCont;", 6) == 0)
1103 require_running (own_buf);
1104 handle_v_cont (own_buf, status, signal);
1108 if (strncmp (own_buf, "vCont?", 6) == 0)
1110 strcpy (own_buf, "vCont;c;C;s;S");
1114 if (strncmp (own_buf, "vFile:", 6) == 0
1115 && handle_vFile (own_buf, packet_len, new_packet_len))
1118 if (strncmp (own_buf, "vAttach;", 8) == 0)
1120 if (target_running ())
1122 fprintf (stderr, "Already debugging a process\n");
1123 write_enn (own_buf);
1126 handle_v_attach (own_buf, status, signal);
1130 if (strncmp (own_buf, "vRun;", 5) == 0)
1132 if (target_running ())
1134 fprintf (stderr, "Already debugging a process\n");
1135 write_enn (own_buf);
1138 handle_v_run (own_buf, status, signal);
1142 /* Otherwise we didn't know what packet it was. Say we didn't
1149 myresume (char *own_buf, int step, int *signalp, char *statusp)
1151 struct thread_resume resume_info[2];
1155 set_desired_inferior (0);
1157 if (step || sig || (cont_thread != 0 && cont_thread != -1))
1159 resume_info[0].thread
1160 = ((struct inferior_list_entry *) current_inferior)->id;
1161 resume_info[0].step = step;
1162 resume_info[0].sig = sig;
1163 resume_info[0].leave_stopped = 0;
1166 resume_info[n].thread = -1;
1167 resume_info[n].step = 0;
1168 resume_info[n].sig = 0;
1169 resume_info[n].leave_stopped = (cont_thread != 0 && cont_thread != -1);
1172 (*the_target->resume) (resume_info);
1173 *signalp = mywait (statusp, 1);
1174 prepare_resume_reply (own_buf, *statusp, *signalp);
1175 disable_async_io ();
1179 gdbserver_version (void)
1181 printf ("GNU gdbserver %s%s\n"
1182 "Copyright (C) 2007 Free Software Foundation, Inc.\n"
1183 "gdbserver is free software, covered by the GNU General Public License.\n"
1184 "This gdbserver was configured as \"%s\"\n",
1185 PKGVERSION, version, host_name);
1189 gdbserver_usage (FILE *stream)
1191 fprintf (stream, "Usage:\tgdbserver [OPTIONS] COMM PROG [ARGS ...]\n"
1192 "\tgdbserver [OPTIONS] --attach COMM PID\n"
1193 "\tgdbserver [OPTIONS] --multi COMM\n"
1195 "COMM may either be a tty device (for serial debugging), or \n"
1196 "HOST:PORT to listen for a TCP connection.\n"
1199 " --debug\t\tEnable debugging output.\n"
1200 " --wrapper WRAPPER --\tRun WRAPPER to start new programs.\n");
1201 if (REPORT_BUGS_TO[0] && stream == stdout)
1202 fprintf (stream, "Report bugs to \"%s\".\n", REPORT_BUGS_TO);
1205 #undef require_running
1206 #define require_running(BUF) \
1207 if (!target_running ()) \
1214 main (int argc, char *argv[])
1216 char ch, status, *own_buf;
1217 unsigned char *mem_buf;
1224 char *arg_end, *port;
1225 char **next_arg = &argv[1];
1230 while (*next_arg != NULL && **next_arg == '-')
1232 if (strcmp (*next_arg, "--version") == 0)
1234 gdbserver_version ();
1237 else if (strcmp (*next_arg, "--help") == 0)
1239 gdbserver_usage (stdout);
1242 else if (strcmp (*next_arg, "--attach") == 0)
1244 else if (strcmp (*next_arg, "--multi") == 0)
1246 else if (strcmp (*next_arg, "--wrapper") == 0)
1250 wrapper_argv = next_arg;
1251 while (*next_arg != NULL && strcmp (*next_arg, "--") != 0)
1254 if (next_arg == wrapper_argv || *next_arg == NULL)
1256 gdbserver_usage (stderr);
1260 /* Consume the "--". */
1263 else if (strcmp (*next_arg, "--debug") == 0)
1267 fprintf (stderr, "Unknown argument: %s\n", *next_arg);
1275 if (setjmp (toplevel))
1277 fprintf (stderr, "Exiting\n");
1283 if (port == NULL || (!attach && !multi_mode && *next_arg == NULL))
1285 gdbserver_usage (stderr);
1292 /* --attach used to come after PORT, so allow it there for
1294 if (*next_arg != NULL && strcmp (*next_arg, "--attach") == 0)
1301 && (*next_arg == NULL
1302 || (*next_arg)[0] == '\0'
1303 || (pid = strtoul (*next_arg, &arg_end, 0)) == 0
1305 || next_arg[1] != NULL))
1310 gdbserver_usage (stderr);
1314 initialize_async_io ();
1317 own_buf = malloc (PBUFSIZ + 1);
1318 mem_buf = malloc (PBUFSIZ);
1320 if (pid == 0 && *next_arg != NULL)
1324 n = argc - (next_arg - argv);
1325 program_argv = malloc (sizeof (char *) * (n + 1));
1326 for (i = 0; i < n; i++)
1327 program_argv[i] = strdup (next_arg[i]);
1328 program_argv[i] = NULL;
1330 /* Wait till we are at first instruction in program. */
1331 signal = start_inferior (program_argv, &status);
1333 /* We are now (hopefully) stopped at the first instruction of
1334 the target process. This assumes that the target process was
1335 successfully created. */
1339 if (attach_inferior (pid, &status, &signal) == -1)
1340 error ("Attaching not supported on this target");
1342 /* Otherwise succeeded. */
1350 /* Don't report shared library events on the initial connection,
1351 even if some libraries are preloaded. Avoids the "stopped by
1352 shared library event" notice on gdb side. */
1355 if (setjmp (toplevel))
1357 fprintf (stderr, "Killing inferior\n");
1362 if (status == 'W' || status == 'X')
1367 if (!was_running && !multi_mode)
1369 fprintf (stderr, "No program to debug. GDBserver exiting.\n");
1378 if (setjmp (toplevel) != 0)
1380 /* An error occurred. */
1381 if (response_needed)
1383 write_enn (own_buf);
1388 disable_async_io ();
1389 while (!exit_requested)
1393 int new_packet_len = -1;
1395 response_needed = 0;
1396 packet_len = getpkt (own_buf);
1397 if (packet_len <= 0)
1399 response_needed = 1;
1406 handle_query (own_buf, packet_len, &new_packet_len);
1409 handle_general_set (own_buf);
1412 require_running (own_buf);
1413 fprintf (stderr, "Detaching from inferior\n");
1414 if (detach_inferior () != 0)
1415 write_enn (own_buf);
1420 if (extended_protocol)
1422 /* Treat this like a normal program exit. */
1431 /* If we are attached, then we can exit. Otherwise, we
1432 need to hang around doing nothing, until the child
1442 extended_protocol = 1;
1446 prepare_resume_reply (own_buf, status, signal);
1449 if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's')
1451 unsigned long gdb_id, thread_id;
1453 require_running (own_buf);
1454 gdb_id = strtoul (&own_buf[2], NULL, 16);
1455 if (gdb_id == 0 || gdb_id == -1)
1459 thread_id = gdb_id_to_thread_id (gdb_id);
1462 write_enn (own_buf);
1467 if (own_buf[1] == 'g')
1469 general_thread = thread_id;
1470 set_desired_inferior (1);
1472 else if (own_buf[1] == 'c')
1473 cont_thread = thread_id;
1474 else if (own_buf[1] == 's')
1475 step_thread = thread_id;
1481 /* Silently ignore it so that gdb can extend the protocol
1482 without compatibility headaches. */
1487 require_running (own_buf);
1488 set_desired_inferior (1);
1489 registers_to_string (own_buf);
1492 require_running (own_buf);
1493 set_desired_inferior (1);
1494 registers_from_string (&own_buf[1]);
1498 require_running (own_buf);
1499 decode_m_packet (&own_buf[1], &mem_addr, &len);
1500 if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
1501 convert_int_to_ascii (mem_buf, own_buf, len);
1503 write_enn (own_buf);
1506 require_running (own_buf);
1507 decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
1508 if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
1511 write_enn (own_buf);
1514 require_running (own_buf);
1515 if (decode_X_packet (&own_buf[1], packet_len - 1,
1516 &mem_addr, &len, mem_buf) < 0
1517 || write_inferior_memory (mem_addr, mem_buf, len) != 0)
1518 write_enn (own_buf);
1523 require_running (own_buf);
1524 convert_ascii_to_int (own_buf + 1, &sig, 1);
1525 if (target_signal_to_host_p (sig))
1526 signal = target_signal_to_host (sig);
1529 myresume (own_buf, 0, &signal, &status);
1532 require_running (own_buf);
1533 convert_ascii_to_int (own_buf + 1, &sig, 1);
1534 if (target_signal_to_host_p (sig))
1535 signal = target_signal_to_host (sig);
1538 myresume (own_buf, 1, &signal, &status);
1541 require_running (own_buf);
1543 myresume (own_buf, 0, &signal, &status);
1546 require_running (own_buf);
1548 myresume (own_buf, 1, &signal, &status);
1554 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1555 int len = strtol (lenptr + 1, &dataptr, 16);
1556 char type = own_buf[1];
1558 if (the_target->insert_watchpoint == NULL
1559 || (type < '2' || type > '4'))
1561 /* No watchpoint support or not a watchpoint command;
1562 unrecognized either way. */
1569 require_running (own_buf);
1570 res = (*the_target->insert_watchpoint) (type, addr, len);
1577 write_enn (own_buf);
1585 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
1586 int len = strtol (lenptr + 1, &dataptr, 16);
1587 char type = own_buf[1];
1589 if (the_target->remove_watchpoint == NULL
1590 || (type < '2' || type > '4'))
1592 /* No watchpoint support or not a watchpoint command;
1593 unrecognized either way. */
1600 require_running (own_buf);
1601 res = (*the_target->remove_watchpoint) (type, addr, len);
1608 write_enn (own_buf);
1613 response_needed = 0;
1614 if (!target_running ())
1615 /* The packet we received doesn't make sense - but we
1616 can't reply to it, either. */
1619 fprintf (stderr, "Killing inferior\n");
1622 /* When using the extended protocol, we wait with no
1623 program running. The traditional protocol will exit
1625 if (extended_protocol)
1628 signal = TARGET_SIGNAL_KILL;
1639 unsigned long gdb_id, thread_id;
1641 require_running (own_buf);
1642 gdb_id = strtoul (&own_buf[1], NULL, 16);
1643 thread_id = gdb_id_to_thread_id (gdb_id);
1646 write_enn (own_buf);
1650 if (mythread_alive (thread_id))
1653 write_enn (own_buf);
1657 response_needed = 0;
1659 /* Restarting the inferior is only supported in the
1660 extended protocol. */
1661 if (extended_protocol)
1663 if (target_running ())
1665 fprintf (stderr, "GDBserver restarting\n");
1667 /* Wait till we are at 1st instruction in prog. */
1668 if (program_argv != NULL)
1669 signal = start_inferior (program_argv, &status);
1673 signal = TARGET_SIGNAL_KILL;
1679 /* It is a request we don't understand. Respond with an
1680 empty packet so that gdb knows that we don't support this
1686 /* Extended (long) request. */
1687 handle_v_requests (own_buf, &status, &signal,
1688 packet_len, &new_packet_len);
1692 /* It is a request we don't understand. Respond with an
1693 empty packet so that gdb knows that we don't support this
1699 if (new_packet_len != -1)
1700 putpkt_binary (own_buf, new_packet_len);
1704 response_needed = 0;
1706 if (was_running && (status == 'W' || status == 'X'))
1712 "\nChild exited with status %d\n", signal);
1714 fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n",
1715 target_signal_to_host (signal),
1716 target_signal_to_name (signal));
1718 if (extended_protocol)
1722 fprintf (stderr, "GDBserver exiting\n");
1727 if (status != 'W' && status != 'X')
1731 /* If an exit was requested (using the "monitor exit" command),
1732 terminate now. The only other way to get here is for
1733 getpkt to fail; close the connection and reopen it at the
1739 if (attached && target_running ())
1741 else if (target_running ())
1747 fprintf (stderr, "Remote side has terminated connection. "
1748 "GDBserver will reopen the connection.\n");