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%lx", thread_ptr->id);
 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%lx", thread_ptr->id);
 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       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           resume_info[i].thread = strtoul (p + 1, &q, 16);
 222           if (p == q)
 223             goto err;
 224           p = q;
 225           if (p[0] != ';' && p[0] != 0)
 226             goto err;
 227
 228           i++;
 229         }
 230     }
 231
 232   resume_info[i] = default_action;
 233
 234   /* Still used in occasional places in the backend.  */
 235   if (n == 1 && resume_info[0].thread != -1)
 236     cont_thread = resume_info[0].thread;
 237   else
 238     cont_thread = -1;
 239   set_desired_inferior (0);
 240
 241   (*the_target->resume) (resume_info);
 242
 243   free (resume_info);
 244
 245   *signal = mywait (status, 1);
 246   prepare_resume_reply (own_buf, *status, *signal);
 247   return;
 248
 249 err:
 250   /* No other way to report an error... */
 251   strcpy (own_buf, "");
 252   free (resume_info);
 253   return;
 254 }
 255
 256 /* Handle all of the extended 'v' packets.  */
 257 void
 258 handle_v_requests (char *own_buf, char *status, int *signal)
 259 {
 260   if (strncmp (own_buf, "vCont;", 6) == 0)
 261     {
 262       handle_v_cont (own_buf, status, signal);
 263       return;
 264     }
 265
 266   if (strncmp (own_buf, "vCont?", 6) == 0)
 267     {
 268       strcpy (own_buf, "vCont;c;C;s;S");
 269       return;
 270     }
 271
 272   /* Otherwise we didn't know what packet it was.  Say we didn't
 273      understand it.  */
 274   own_buf[0] = 0;
 275   return;
 276 }
 277
 278 void
 279 myresume (int step, int sig)
 280 {
 281   struct thread_resume resume_info[2];
 282   int n = 0;
 283
 284   if (step || sig || cont_thread > 0)
 285     {
 286       resume_info[0].thread
 287         = ((struct inferior_list_entry *) current_inferior)->id;
 288       resume_info[0].step = step;
 289       resume_info[0].sig = sig;
 290       resume_info[0].leave_stopped = 0;
 291       n++;
 292     }
 293   resume_info[n].thread = -1;
 294   resume_info[n].step = 0;
 295   resume_info[n].sig = 0;
 296   resume_info[n].leave_stopped = (cont_thread > 0);
 297
 298   (*the_target->resume) (resume_info);
 299 }
 300
 301 static int attached;
 302
 303 static void
 304 gdbserver_usage (void)
 305 {
 306   error ("Usage:\tgdbserver COMM PROG [ARGS ...]\n"
 307          "\tgdbserver COMM --attach PID\n"
 308          "\n"
 309          "COMM may either be a tty device (for serial debugging), or \n"
 310          "HOST:PORT to listen for a TCP connection.\n");
 311 }
 312
 313 int
 314 main (int argc, char *argv[])
 315 {
 316   char ch, status, *own_buf, mem_buf[2000];
 317   int i = 0;
 318   int signal;
 319   unsigned int len;
 320   CORE_ADDR mem_addr;
 321   int bad_attach;
 322   int pid;
 323   char *arg_end;
 324
 325   if (setjmp (toplevel))
 326     {
 327       fprintf (stderr, "Exiting\n");
 328       exit (1);
 329     }
 330
 331   bad_attach = 0;
 332   pid = 0;
 333   attached = 0;
 334   if (argc >= 3 && strcmp (argv[2], "--attach") == 0)
 335     {
 336       if (argc == 4
 337           && argv[3] != '\0'
 338           && (pid = strtoul (argv[3], &arg_end, 10)) != 0
 339           && *arg_end == '\0')
 340         {
 341           ;
 342         }
 343       else
 344         bad_attach = 1;
 345     }
 346
 347   if (argc < 3 || bad_attach)
 348     gdbserver_usage();
 349
 350   initialize_low ();
 351
 352   own_buf = malloc (PBUFSIZ);
 353
 354   if (pid == 0)
 355     {
 356       /* Wait till we are at first instruction in program.  */
 357       signal = start_inferior (&argv[2], &status);
 358
 359       /* We are now stopped at the first instruction of the target process */
 360     }
 361   else
 362     {
 363       switch (attach_inferior (pid, &status, &signal))
 364         {
 365         case -1:
 366           error ("Attaching not supported on this target");
 367           break;
 368         default:
 369           attached = 1;
 370           break;
 371         }
 372     }
 373
 374   while (1)
 375     {
 376       remote_open (argv[1]);
 377
 378     restart:
 379       setjmp (toplevel);
 380       while (getpkt (own_buf) > 0)
 381         {
 382           unsigned char sig;
 383           i = 0;
 384           ch = own_buf[i++];
 385           switch (ch)
 386             {
 387             case 'q':
 388               handle_query (own_buf);
 389               break;
 390             case 'd':
 391               remote_debug = !remote_debug;
 392               break;
 393             case 'D':
 394               fprintf (stderr, "Detaching from inferior\n");
 395               detach_inferior ();
 396               write_ok (own_buf);
 397               putpkt (own_buf);
 398               remote_close ();
 399
 400               /* If we are attached, then we can exit.  Otherwise, we need to
 401                  hang around doing nothing, until the child is gone.  */
 402               if (!attached)
 403                 {
 404                   int status, ret;
 405
 406                   do {
 407                     ret = waitpid (signal_pid, &status, 0);
 408                     if (WIFEXITED (status) || WIFSIGNALED (status))
 409                       break;
 410                   } while (ret != -1 || errno != ECHILD);
 411                 }
 412
 413               exit (0);
 414
 415             case '!':
 416               if (attached == 0)
 417                 {
 418                   extended_protocol = 1;
 419                   prepare_resume_reply (own_buf, status, signal);
 420                 }
 421               else
 422                 {
 423                   /* We can not use the extended protocol if we are
 424                      attached, because we can not restart the running
 425                      program.  So return unrecognized.  */
 426                   own_buf[0] = '\0';
 427                 }
 428               break;
 429             case '?':
 430               prepare_resume_reply (own_buf, status, signal);
 431               break;
 432             case 'H':
 433               switch (own_buf[1])
 434                 {
 435                 case 'g':
 436                   general_thread = strtoul (&own_buf[2], NULL, 16);
 437                   write_ok (own_buf);
 438                   set_desired_inferior (1);
 439                   break;
 440                 case 'c':
 441                   cont_thread = strtoul (&own_buf[2], NULL, 16);
 442                   write_ok (own_buf);
 443                   break;
 444                 case 's':
 445                   step_thread = strtoul (&own_buf[2], NULL, 16);
 446                   write_ok (own_buf);
 447                   break;
 448                 default:
 449                   /* Silently ignore it so that gdb can extend the protocol
 450                      without compatibility headaches.  */
 451                   own_buf[0] = '\0';
 452                   break;
 453                 }
 454               break;
 455             case 'g':
 456               set_desired_inferior (1);
 457               registers_to_string (own_buf);
 458               break;
 459             case 'G':
 460               set_desired_inferior (1);
 461               registers_from_string (&own_buf[1]);
 462               write_ok (own_buf);
 463               break;
 464             case 'm':
 465               decode_m_packet (&own_buf[1], &mem_addr, &len);
 466               if (read_inferior_memory (mem_addr, mem_buf, len) == 0)
 467                 convert_int_to_ascii (mem_buf, own_buf, len);
 468               else
 469                 write_enn (own_buf);
 470               break;
 471             case 'M':
 472               decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf);
 473               if (write_inferior_memory (mem_addr, mem_buf, len) == 0)
 474                 write_ok (own_buf);
 475               else
 476                 write_enn (own_buf);
 477               break;
 478             case 'C':
 479               convert_ascii_to_int (own_buf + 1, &sig, 1);
 480               if (target_signal_to_host_p (sig))
 481                 signal = target_signal_to_host (sig);
 482               else
 483                 signal = 0;
 484               set_desired_inferior (0);
 485               myresume (0, signal);
 486               signal = mywait (&status, 1);
 487               prepare_resume_reply (own_buf, status, signal);
 488               break;
 489             case 'S':
 490               convert_ascii_to_int (own_buf + 1, &sig, 1);
 491               if (target_signal_to_host_p (sig))
 492                 signal = target_signal_to_host (sig);
 493               else
 494                 signal = 0;
 495               set_desired_inferior (0);
 496               myresume (1, signal);
 497               signal = mywait (&status, 1);
 498               prepare_resume_reply (own_buf, status, signal);
 499               break;
 500             case 'c':
 501               set_desired_inferior (0);
 502               myresume (0, 0);
 503               signal = mywait (&status, 1);
 504               prepare_resume_reply (own_buf, status, signal);
 505               break;
 506             case 's':
 507               set_desired_inferior (0);
 508               myresume (1, 0);
 509               signal = mywait (&status, 1);
 510               prepare_resume_reply (own_buf, status, signal);
 511               break;
 512             case 'Z':
 513               {
 514                 char *lenptr;
 515                 char *dataptr;
 516                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
 517                 int len = strtol (lenptr + 1, &dataptr, 16);
 518                 char type = own_buf[1];
 519
 520                 if (the_target->insert_watchpoint == NULL
 521                     || (type < '2' || type > '4'))
 522                   {
 523                     /* No watchpoint support or not a watchpoint command;
 524                        unrecognized either way.  */
 525                     own_buf[0] = '\0';
 526                   }
 527                 else
 528                   {
 529                     int res;
 530
 531                     res = (*the_target->insert_watchpoint) (type, addr, len);
 532                     if (res == 0)
 533                       write_ok (own_buf);
 534                     else if (res == 1)
 535                       /* Unsupported.  */
 536                       own_buf[0] = '\0';
 537                     else
 538                       write_enn (own_buf);
 539                   }
 540                 break;
 541               }
 542             case 'z':
 543               {
 544                 char *lenptr;
 545                 char *dataptr;
 546                 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16);
 547                 int len = strtol (lenptr + 1, &dataptr, 16);
 548                 char type = own_buf[1];
 549
 550                 if (the_target->remove_watchpoint == NULL
 551                     || (type < '2' || type > '4'))
 552                   {
 553                     /* No watchpoint support or not a watchpoint command;
 554                        unrecognized either way.  */
 555                     own_buf[0] = '\0';
 556                   }
 557                 else
 558                   {
 559                     int res;
 560
 561                     res = (*the_target->remove_watchpoint) (type, addr, len);
 562                     if (res == 0)
 563                       write_ok (own_buf);
 564                     else if (res == 1)
 565                       /* Unsupported.  */
 566                       own_buf[0] = '\0';
 567                     else
 568                       write_enn (own_buf);
 569                   }
 570                 break;
 571               }
 572             case 'k':
 573               fprintf (stderr, "Killing inferior\n");
 574               kill_inferior ();
 575               /* When using the extended protocol, we start up a new
 576                  debugging session.   The traditional protocol will
 577                  exit instead.  */
 578               if (extended_protocol)
 579                 {
 580                   write_ok (own_buf);
 581                   fprintf (stderr, "GDBserver restarting\n");
 582
 583                   /* Wait till we are at 1st instruction in prog.  */
 584                   signal = start_inferior (&argv[2], &status);
 585                   goto restart;
 586                   break;
 587                 }
 588               else
 589                 {
 590                   exit (0);
 591                   break;
 592                 }
 593             case 'T':
 594               if (mythread_alive (strtoul (&own_buf[1], NULL, 16)))
 595                 write_ok (own_buf);
 596               else
 597                 write_enn (own_buf);
 598               break;
 599             case 'R':
 600               /* Restarting the inferior is only supported in the
 601                  extended protocol.  */
 602               if (extended_protocol)
 603                 {
 604                   kill_inferior ();
 605                   write_ok (own_buf);
 606                   fprintf (stderr, "GDBserver restarting\n");
 607
 608                   /* Wait till we are at 1st instruction in prog.  */
 609                   signal = start_inferior (&argv[2], &status);
 610                   goto restart;
 611                   break;
 612                 }
 613               else
 614                 {
 615                   /* It is a request we don't understand.  Respond with an
 616                      empty packet so that gdb knows that we don't support this
 617                      request.  */
 618                   own_buf[0] = '\0';
 619                   break;
 620                 }
 621             case 'v':
 622               /* Extended (long) request.  */
 623               handle_v_requests (own_buf, &status, &signal);
 624               break;
 625             default:
 626               /* It is a request we don't understand.  Respond with an
 627                  empty packet so that gdb knows that we don't support this
 628                  request.  */
 629               own_buf[0] = '\0';
 630               break;
 631             }
 632
 633           putpkt (own_buf);
 634
 635           if (status == 'W')
 636             fprintf (stderr,
 637                      "\nChild exited with status %d\n", signal);
 638           if (status == 'X')
 639             fprintf (stderr, "\nChild terminated with signal = 0x%x\n",
 640                      signal);
 641           if (status == 'W' || status == 'X')
 642             {
 643               if (extended_protocol)
 644                 {
 645                   fprintf (stderr, "Killing inferior\n");
 646                   kill_inferior ();
 647                   write_ok (own_buf);
 648                   fprintf (stderr, "GDBserver restarting\n");
 649
 650                   /* Wait till we are at 1st instruction in prog.  */
 651                   signal = start_inferior (&argv[2], &status);
 652                   goto restart;
 653                   break;
 654                 }
 655               else
 656                 {
 657                   fprintf (stderr, "GDBserver exiting\n");
 658                   exit (0);
 659                 }
 660             }
 661         }
 662
 663       /* We come here when getpkt fails.
 664
 665          For the extended remote protocol we exit (and this is the only
 666          way we gracefully exit!).
 667
 668          For the traditional remote protocol close the connection,
 669          and re-open it at the top of the loop.  */
 670       if (extended_protocol)
 671         {
 672           remote_close ();
 673           exit (0);
 674         }
 675       else
 676         {
 677           fprintf (stderr, "Remote side has terminated connection.  "
 678                            "GDBserver will reopen the connection.\n");
 679           remote_close ();
 680         }
 681     }
 682 }