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