1 /* Main code for remote server for GDB.
2 Copyright 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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 2 of the License, or
10 (at your option) any later version.
11
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.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 #include "server.h"
23
24 #include <unistd.h>
25 #include <signal.h>
26 #include <sys/wait.h>
27
28 int cont_thread;
29 int general_thread;
30 int step_thread;
31 int thread_from_wait;
32 int old_thread_from_wait;
33 int extended_protocol;
34 int server_waiting;
35
36 jmp_buf toplevel;
37
38 /* The PID of the originally created or attached inferior. Used to
39 send signals to the process when GDB sends us an asynchronous interrupt
40 (user hitting Control-C in the client), and to wait for the child to exit
41 when no longer debugging it. */
42
43 int signal_pid;
44
45 static unsigned char
start_inferior(char * argv[],char * statusptr)46 start_inferior (char *argv[], char *statusptr)
47 {
48 signal (SIGTTOU, SIG_DFL);
49 signal (SIGTTIN, SIG_DFL);
50
51 signal_pid = create_inferior (argv[0], argv);
52
53 fprintf (stderr, "Process %s created; pid = %d\n", argv[0],
54 signal_pid);
55
56 signal (SIGTTOU, SIG_IGN);
57 signal (SIGTTIN, SIG_IGN);
58 tcsetpgrp (fileno (stderr), signal_pid);
59
60 /* Wait till we are at 1st instruction in program, return signal number. */
61 return mywait (statusptr, 0);
62 }
63
64 static int
attach_inferior(int pid,char * statusptr,unsigned char * sigptr)65 attach_inferior (int pid, char *statusptr, unsigned char *sigptr)
66 {
67 /* myattach should return -1 if attaching is unsupported,
68 0 if it succeeded, and call error() otherwise. */
69
70 if (myattach (pid) != 0)
71 return -1;
72
73 fprintf (stderr, "Attached; pid = %d\n", pid);
74
75 /* FIXME - It may be that we should get the SIGNAL_PID from the
76 attach function, so that it can be the main thread instead of
77 whichever we were told to attach to. */
78 signal_pid = pid;
79
80 *sigptr = mywait (statusptr, 0);
81
82 return 0;
83 }
84
85 extern int remote_debug;
86
87 /* Handle all of the extended 'q' packets. */
88 void
handle_query(char * own_buf)89 handle_query (char *own_buf)
90 {
91 static struct inferior_list_entry *thread_ptr;
92
93 if (strcmp ("qSymbol::", own_buf) == 0)
94 {
95 if (the_target->look_up_symbols != NULL)
96 (*the_target->look_up_symbols) ();
97
98 strcpy (own_buf, "OK");
99 return;
100 }
101
102 if (strcmp ("qfThreadInfo", own_buf) == 0)
103 {
104 thread_ptr = all_threads.head;
105 sprintf (own_buf, "m%x", thread_ptr->id);
106 thread_ptr = thread_ptr->next;
107 return;
108 }
109
110 if (strcmp ("qsThreadInfo", own_buf) == 0)
111 {
112 if (thread_ptr != NULL)
113 {
114 sprintf (own_buf, "m%x", thread_ptr->id);
115 thread_ptr = thread_ptr->next;
116 return;
117 }
118 else
119 {
120 sprintf (own_buf, "l");
121 return;
122 }
123 }
124
125 if (the_target->read_auxv != NULL
126 && strncmp ("qPart:auxv:read::", own_buf, 17) == 0)
127 {
128 char data[(PBUFSIZ - 1) / 2];
129 CORE_ADDR ofs;
130 unsigned int len;
131 int n;
132 decode_m_packet (&own_buf[17], &ofs, &len); /* "OFS,LEN" */
133 if (len > sizeof data)
134 len = sizeof data;
135 n = (*the_target->read_auxv) (ofs, data, len);
136 if (n == 0)
137 write_ok (own_buf);
138 else if (n < 0)
139 write_enn (own_buf);
140 else
141 convert_int_to_ascii (data, own_buf, n);
142 return;
143 }
144
145 /* Otherwise we didn't know what packet it was. Say we didn't
146 understand it. */
147 own_buf[0] = 0;
148 }
149
150 /* Parse vCont packets. */
151 void
handle_v_cont(char * own_buf,char * status,unsigned char * signal)152 handle_v_cont (char *own_buf, char *status, unsigned char *signal)
153 {
154 char *p, *q;
155 int n = 0, i = 0;
156 struct thread_resume *resume_info, default_action;
157
158 /* Count the number of semicolons in the packet. There should be one
159 for every action. */
160 p = &own_buf[5];
161 while (p)
162 {
163 n++;
164 p++;
165 p = strchr (p, ';');
166 }
167 /* Allocate room for one extra action, for the default remain-stopped
168 behavior; if no default action is in the list, we'll need the extra
169 slot. */
170 resume_info = malloc ((n + 1) * sizeof (resume_info[0]));
171
172 default_action.thread = -1;
173 default_action.leave_stopped = 1;
174 default_action.step = 0;
175 default_action.sig = 0;
176
177 p = &own_buf[5];
178 i = 0;
179 while (*p)
180 {
181 p++;
182
183 resume_info[i].leave_stopped = 0;
184
185 if (p[0] == 's' || p[0] == 'S')
186 resume_info[i].step = 1;
187 else if (p[0] == 'c' || p[0] == 'C')
188 resume_info[i].step = 0;
189 else
190 goto err;
191
192 if (p[0] == 'S' || p[0] == 'C')
193 {
194 int sig;
195 sig = strtol (p + 1, &q, 16);
196 if (p == q)
197 goto err;
198 p = q;
199
200 if (!target_signal_to_host_p (sig))
201 goto err;
202 resume_info[i].sig = target_signal_to_host (sig);
203 }
204 else
205 {
206 resume_info[i].sig = 0;
207 p = p + 1;
208 }
209
210 if (p[0] == 0)
211 {
212 resume_info[i].thread = -1;
213 default_action = resume_info[i];
214
215 /* Note: we don't increment i here, we'll overwrite this entry
216 the next time through. */
217 }
218 else if (p[0] == ':')
219 {
220 resume_info[i].thread = strtol (p + 1, &q, 16);
221 if (p == q)
222 goto err;
223 p = q;
224 if (p[0] != ';' && p[0] != 0)
225 goto err;
226
227 i++;
228 }
229 }
230
231 resume_info[i] = default_action;
232
233 /* Still used in occasional places in the backend. */
234 if (n == 1 && resume_info[0].thread != -1)
235 cont_thread = resume_info[0].thread;
236 else
237 cont_thread = -1;
238 set_desired_inferior (0);
239
240 (*the_target->resume) (resume_info);
241
242 free (resume_info);
243
244 *signal = mywait (status, 1);
245 prepare_resume_reply (own_buf, *status, *signal);
246 return;
247
248 err:
249 /* No other way to report an error... */
250 strcpy (own_buf, "");
251 free (resume_info);
252 return;
253 }
254
255 /* Handle all of the extended 'v' packets. */
256 void
handle_v_requests(char * own_buf,char * status,unsigned char * signal)257 handle_v_requests (char *own_buf, char *status, unsigned char *signal)
258 {
259 if (strncmp (own_buf, "vCont;", 6) == 0)
260 {
261 handle_v_cont (own_buf, status, signal);
262 return;
263 }
264
265 if (strncmp (own_buf, "vCont?", 6) == 0)
266 {
267 strcpy (own_buf, "vCont;c;C;s;S");
268 return;
269 }
270
271 /* Otherwise we didn't know what packet it was. Say we didn't
272 understand it. */
273 own_buf[0] = 0;
274 return;
275 }
276
277 void
myresume(int step,int sig)278 myresume (int step, int sig)
279 {
280 struct thread_resume resume_info[2];
281 int n = 0;
282
283 if (step || sig || cont_thread > 0)
284 {
285 resume_info[0].thread
286 = ((struct inferior_list_entry *) current_inferior)->id;
287 resume_info[0].step = step;
288 resume_info[0].sig = sig;
289 resume_info[0].leave_stopped = 0;
290 n++;
291 }
292 resume_info[n].thread = -1;
293 resume_info[n].step = 0;
294 resume_info[n].sig = 0;
295 resume_info[n].leave_stopped = (cont_thread > 0);
296
297 (*the_target->resume) (resume_info);
298 }
299
300 static int attached;
301
302 static void
gdbserver_usage(void)303 gdbserver_usage (void)
304 {
305 error ("Usage:\tgdbserver COMM PROG [ARGS ...]\n"
306 "\tgdbserver COMM --attach PID\n"
307 "\n"
308 "COMM may either be a tty device (for serial debugging), or \n"
309 "HOST:PORT to listen for a TCP connection.\n");
310 }
311
312 int
main(int argc,char * argv[])313 main (int argc, char *argv[])
314 {
315 char ch, status, *own_buf, mem_buf[2000];
316 int i = 0;
317 unsigned char signal;
318 unsigned int len;
319 CORE_ADDR mem_addr;
320 int bad_attach;
321 int pid;
322 char *arg_end;
323
324 if (setjmp (toplevel))
325 {
326 fprintf (stderr, "Exiting\n");
327 exit (1);
328 }
329
330 bad_attach = 0;
331 pid = 0;
332 attached = 0;
333 if (argc >= 3 && strcmp (argv[2], "--attach") == 0)
334 {
335 if (argc == 4
336 && argv[3] != '\0'
337 && (pid = strtoul (argv[3], &arg_end, 10)) != 0
338 && *arg_end == '\0')
339 {
340 ;
341 }
342 else
343 bad_attach = 1;
344 }
345
346 if (argc < 3 || bad_attach)
347 gdbserver_usage();
348
349 initialize_low ();
350
351 own_buf = malloc (PBUFSIZ);
352
353 if (pid == 0)
354 {
355 /* Wait till we are at first instruction in program. */
356 signal = start_inferior (&argv[2], &status);
357
358 /* We are now stopped at the first instruction of the target process */
359 }
360 else
361 {
362 switch (attach_inferior (pid, &status, &signal))
363 {
364 case -1:
365 error ("Attaching not supported on this target");
366 break;
367 default:
368 attached = 1;
369 break;
370 }
371 }
372
373 while (1)
374 {
375 remote_open (argv[1]);
376
377 restart:
378 setjmp (toplevel);
379 while (getpkt (own_buf) > 0)
380 {
381 unsigned char sig;
382 i = 0;
383 ch = own_buf[i++];
384 switch (ch)
385 {
386 case 'q':
387 handle_query (own_buf);
388 break;
389 case 'd':
390 remote_debug = !remote_debug;
391 break;
392 case 'D':
393 fprintf (stderr, "Detaching from inferior\n");
394 detach_inferior ();
395 write_ok (own_buf);
396 putpkt (own_buf);
397 remote_close ();
398
399 /* If we are attached, then we can exit. Otherwise, we need to
400 hang around doing nothing, until the child is gone. */
401 if (!attached)
402 {
403 int status, ret;
404
405 do {
406 ret = waitpid (signal_pid, &status, 0);
407 if (WIFEXITED (status) || WIFSIGNALED (status))
408 break;
409 } while (ret != -1 || errno != ECHILD);
410 }
411
412 exit (0);
413
414 case '!':
415 if (attached == 0)
416 {
417 extended_protocol = 1;
418 prepare_resume_reply (own_buf, status, signal);
419 }
420 else
421 {
422 /* We can not use the extended protocol if we are
423 attached, because we can not restart the running
424 program. So return unrecognized. */
425 own_buf[0] = '\0';
426 }
427 break;
428 case '?':
429 prepare_resume_reply (own_buf, status, signal);
430 break;
431 case 'H':
432 switch (own_buf[1])
433 {
434 case 'g':
435 general_thread = strtol (&own_buf[2], NULL, 16);
436 write_ok (own_buf);
437 set_desired_inferior (1);
438 break;
439 case 'c':
440 cont_thread = strtol (&own_buf[2], NULL, 16);
441 write_ok (own_buf);
442 break;
443 case 's':
444 step_thread = strtol (&own_buf[2], NULL, 16);
445 write_ok (own_buf);
446 break;
447 default:
448 /* Silently ignore it so that gdb can extend the protocol
449 without compatibility headaches. */
450 own_buf[0] = '\0';
451 break;
452 }
453 break;
454 case 'g':
455 set_desired_inferior (1);
456 registers_to_string (own_buf);
457 break;
458 case 'G':
459 set_desired_inferior (1);
460 registers_from_string (&own_buf[1]);
461 write_ok (own_buf);
462 break;
463 case 'm':
464 decode_m_packet (&own_buf[1], &mem_addr, &len);
465 if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
466 convert_int_to_ascii (mem_buf, own_buf, len);
467 else
468 write_enn (own_buf);
469 break;
470 case 'M':
471 decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
472 if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
473 write_ok (own_buf);
474 else
475 write_enn (own_buf);
476 break;
477 case 'C':
478 convert_ascii_to_int (own_buf + 1, &sig, 1);
479 if (target_signal_to_host_p (sig))
480 signal = target_signal_to_host (sig);
481 else
482 signal = 0;
483 set_desired_inferior (0);
484 myresume (0, signal);
485 signal = mywait (&status, 1);
486 prepare_resume_reply (own_buf, status, signal);
487 break;
488 case 'S':
489 convert_ascii_to_int (own_buf + 1, &sig, 1);
490 if (target_signal_to_host_p (sig))
491 signal = target_signal_to_host (sig);
492 else
493 signal = 0;
494 set_desired_inferior (0);
495 myresume (1, signal);
496 signal = mywait (&status, 1);
497 prepare_resume_reply (own_buf, status, signal);
498 break;
499 case 'c':
500 set_desired_inferior (0);
501 myresume (0, 0);
502 signal = mywait (&status, 1);
503 prepare_resume_reply (own_buf, status, signal);
504 break;
505 case 's':
506 set_desired_inferior (0);
507 myresume (1, 0);
508 signal = mywait (&status, 1);
509 prepare_resume_reply (own_buf, status, signal);
510 break;
511 case 'k':
512 fprintf (stderr, "Killing inferior\n");
513 kill_inferior ();
514 /* When using the extended protocol, we start up a new
515 debugging session. The traditional protocol will
516 exit instead. */
517 if (extended_protocol)
518 {
519 write_ok (own_buf);
520 fprintf (stderr, "GDBserver restarting\n");
521
522 /* Wait till we are at 1st instruction in prog. */
523 signal = start_inferior (&argv[2], &status);
524 goto restart;
525 break;
526 }
527 else
528 {
529 exit (0);
530 break;
531 }
532 case 'T':
533 if (mythread_alive (strtol (&own_buf[1], NULL, 16)))
534 write_ok (own_buf);
535 else
536 write_enn (own_buf);
537 break;
538 case 'R':
539 /* Restarting the inferior is only supported in the
540 extended protocol. */
541 if (extended_protocol)
542 {
543 kill_inferior ();
544 write_ok (own_buf);
545 fprintf (stderr, "GDBserver restarting\n");
546
547 /* Wait till we are at 1st instruction in prog. */
548 signal = start_inferior (&argv[2], &status);
549 goto restart;
550 break;
551 }
552 else
553 {
554 /* It is a request we don't understand. Respond with an
555 empty packet so that gdb knows that we don't support this
556 request. */
557 own_buf[0] = '\0';
558 break;
559 }
560 case 'v':
561 /* Extended (long) request. */
562 handle_v_requests (own_buf, &status, &signal);
563 break;
564 default:
565 /* It is a request we don't understand. Respond with an
566 empty packet so that gdb knows that we don't support this
567 request. */
568 own_buf[0] = '\0';
569 break;
570 }
571
572 putpkt (own_buf);
573
574 if (status == 'W')
575 fprintf (stderr,
576 "\nChild exited with status %d\n", signal);
577 if (status == 'X')
578 fprintf (stderr, "\nChild terminated with signal = 0x%x\n",
579 signal);
580 if (status == 'W' || status == 'X')
581 {
582 if (extended_protocol)
583 {
584 fprintf (stderr, "Killing inferior\n");
585 kill_inferior ();
586 write_ok (own_buf);
587 fprintf (stderr, "GDBserver restarting\n");
588
589 /* Wait till we are at 1st instruction in prog. */
590 signal = start_inferior (&argv[2], &status);
591 goto restart;
592 break;
593 }
594 else
595 {
596 fprintf (stderr, "GDBserver exiting\n");
597 exit (0);
598 }
599 }
600 }
601
602 /* We come here when getpkt fails.
603
604 For the extended remote protocol we exit (and this is the only
605 way we gracefully exit!).
606
607 For the traditional remote protocol close the connection,
608 and re-open it at the top of the loop. */
609 if (extended_protocol)
610 {
611 remote_close ();
612 exit (0);
613 }
614 else
615 {
616 fprintf (stderr, "Remote side has terminated connection. "
617 "GDBserver will reopen the connection.\n");
618 remote_close ();
619 }
620 }
621 }
622