gdb/gdbserver/server.c

   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
  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
  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
  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
 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
 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
 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
 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
 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 }