1 /*--------------------------------------------------------------------*/ 2 /*--- Relay between gdb and gdbserver embedded in valgrind vgdb.c ---*/ 3 /*--------------------------------------------------------------------*/ 4 5 /* 6 This file is part of Valgrind, a dynamic binary instrumentation 7 framework. 8 9 Copyright (C) 2011-2017 Philippe Waroquiers 10 11 This program is free software; you can redistribute it and/or 12 modify it under the terms of the GNU General Public License as 13 published by the Free Software Foundation; either version 2 of the 14 License, or (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, but 17 WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program; if not, write to the Free Software 23 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 24 02111-1307, USA. 25 26 The GNU General Public License is contained in the file COPYING. 27 */ 28 29 #include "vgdb.h" 30 31 #include "config.h" 32 33 #include <assert.h> 34 #include <dirent.h> 35 #include <errno.h> 36 #include <fcntl.h> 37 #include <limits.h> 38 #include <poll.h> 39 #include <pthread.h> 40 #include <signal.h> 41 #include <stdlib.h> 42 #include <stdio.h> 43 #include <string.h> 44 #include <unistd.h> 45 #include <netinet/in.h> 46 #include <sys/mman.h> 47 #include <sys/socket.h> 48 #include <sys/stat.h> 49 #include <sys/time.h> 50 51 /* vgdb has two usages: 52 1. relay application between gdb and the gdbserver embedded in valgrind. 53 2. standalone to send monitor commands to a running valgrind-ified process 54 55 It is made of a main program which reads arguments. If no 56 arguments are given or only --pid and --vgdb-prefix, then usage 1 is 57 assumed. 58 59 As relay application, vgdb reads bytes from gdb on stdin and 60 writes these bytes to valgrind. Bytes read from valgrind are 61 written to gdb on stdout. Read/Write from/to valgrind is done 62 using FIFOs. There is one thread reading from stdin, writing to 63 valgrind on a FIFO. There is one thread reading from valgrind on a 64 FIFO, writing to gdb on stdout 65 66 As a standalone utility, vgdb builds command packets to write to valgrind, 67 sends it and reads the reply. The same two threads are used to write/read. 68 Once all the commands are sent and their replies received, vgdb will exit. 69 */ 70 71 int debuglevel; 72 struct timeval dbgtv; 73 static char *vgdb_prefix = NULL; 74 75 /* Will be set to True when any condition indicating we have to shutdown 76 is encountered. */ 77 Bool shutting_down = False; 78 79 VgdbShared32 *shared32; 80 VgdbShared64 *shared64; 81 #define VS_written_by_vgdb (shared32 != NULL ? \ 82 shared32->written_by_vgdb \ 83 : shared64->written_by_vgdb) 84 #define VS_seen_by_valgrind (shared32 != NULL ? \ 85 shared32->seen_by_valgrind \ 86 : shared64->seen_by_valgrind) 87 88 #define VS_vgdb_pid (shared32 != NULL ? shared32->vgdb_pid : shared64->vgdb_pid) 89 90 void *vmalloc(size_t size) 91 { 92 void * mem = malloc(size); 93 if (mem == NULL) 94 XERROR (errno, "can't allocate memory\n"); 95 return mem; 96 } 97 98 void *vrealloc(void *ptr,size_t size) 99 { 100 void * mem = realloc(ptr, size); 101 if (mem == NULL) 102 XERROR (errno, "can't reallocate memory\n"); 103 return mem; 104 } 105 106 /* Return the name of a directory for temporary files. */ 107 static 108 const char *vgdb_tmpdir(void) 109 { 110 const char *tmpdir; 111 112 tmpdir = getenv("TMPDIR"); 113 if (tmpdir == NULL || *tmpdir == '\0') 114 tmpdir = VG_TMPDIR; 115 if (tmpdir == NULL || *tmpdir == '\0') 116 tmpdir = "/tmp"; /* fallback */ 117 118 return tmpdir; 119 } 120 121 /* Return the default path prefix for the named pipes (FIFOs) used by vgdb/gdb 122 to communicate with valgrind */ 123 static 124 char *vgdb_prefix_default(void) 125 { 126 static HChar *prefix; 127 128 if (prefix == NULL) { 129 const char *tmpdir = vgdb_tmpdir(); 130 prefix = vmalloc(strlen(tmpdir) + strlen("/vgdb-pipe") + 1); 131 strcpy(prefix, tmpdir); 132 strcat(prefix, "/vgdb-pipe"); 133 } 134 return prefix; 135 } 136 137 /* add nrw to the written_by_vgdb field of shared32 or shared64 */ 138 static 139 void add_written(int nrw) 140 { 141 if (shared32 != NULL) 142 shared32->written_by_vgdb += nrw; 143 else if (shared64 != NULL) 144 shared64->written_by_vgdb += nrw; 145 else 146 assert(0); 147 } 148 149 static int shared_mem_fd = -1; 150 static 151 void map_vgdbshared (char* shared_mem) 152 { 153 struct stat fdstat; 154 void **s; 155 shared_mem_fd = open(shared_mem, O_RDWR); 156 /* shared_mem_fd will not be closed till vgdb exits. */ 157 158 if (shared_mem_fd == -1) 159 XERROR (errno, "error opening %s shared memory file\n", shared_mem); 160 161 if (fstat(shared_mem_fd, &fdstat) != 0) 162 XERROR (errno, "fstat"); 163 164 if (fdstat.st_size == sizeof(VgdbShared64)) 165 s = (void*) &shared64; 166 else if (fdstat.st_size == sizeof(VgdbShared32)) 167 s = (void*) &shared32; 168 else 169 #if VEX_HOST_WORDSIZE == 8 170 XERROR (0, 171 "error size shared memory file %s.\n" 172 "expecting size %d (64bits) or %d (32bits) got %ld.\n", 173 shared_mem, 174 (int) sizeof(VgdbShared64), (int) sizeof(VgdbShared32), 175 (long int)fdstat.st_size); 176 #elif VEX_HOST_WORDSIZE == 4 177 XERROR (0, 178 "error size shared memory file %s.\n" 179 "expecting size %d (32bits) got %ld.\n", 180 shared_mem, 181 (int) sizeof(VgdbShared32), 182 fdstat.st_size); 183 #else 184 # error "unexpected wordsize" 185 #endif 186 187 #if VEX_HOST_WORDSIZE == 4 188 if (shared64 != NULL) 189 XERROR (0, "cannot use 32 bits vgdb with a 64bits valgrind process\n"); 190 /* But we can use a 64 bits vgdb with a 32 bits valgrind */ 191 #endif 192 193 *s = (void*) mmap (NULL, fdstat.st_size, 194 PROT_READ|PROT_WRITE, MAP_SHARED, 195 shared_mem_fd, 0); 196 197 if (*s == (void *) -1) 198 XERROR (errno, "error mmap shared memory file %s\n", shared_mem); 199 200 } 201 202 /* This function loops till shutting_down becomes true. In this loop, 203 it verifies if valgrind process is reading the characters written 204 by vgdb. The verification is done every max_invoke_ms ms. If 205 valgrind is not reading characters, it will use invoker_invoke_gdbserver 206 to ensure that the gdbserver code is called soon by valgrind. */ 207 static int max_invoke_ms = 100; 208 #define NEVER 99999999 209 static int cmd_time_out = NEVER; 210 static 211 void *invoke_gdbserver_in_valgrind(void *v_pid) 212 { 213 struct timeval cmd_max_end_time; 214 Bool cmd_started = False; 215 struct timeval invoke_time; 216 217 int pid = *(int *)v_pid; 218 int written_by_vgdb_before_sleep; 219 int seen_by_valgrind_before_sleep; 220 221 int invoked_written = -1; 222 unsigned int usecs; 223 224 pthread_cleanup_push(invoker_cleanup_restore_and_detach, v_pid); 225 226 while (!shutting_down) { 227 written_by_vgdb_before_sleep = VS_written_by_vgdb; 228 seen_by_valgrind_before_sleep = VS_seen_by_valgrind; 229 DEBUG(3, 230 "written_by_vgdb_before_sleep %d " 231 "seen_by_valgrind_before_sleep %d\n", 232 written_by_vgdb_before_sleep, 233 seen_by_valgrind_before_sleep); 234 if (cmd_time_out != NEVER 235 && !cmd_started 236 && written_by_vgdb_before_sleep > seen_by_valgrind_before_sleep) { 237 /* A command was started. Record the time at which it was started. */ 238 DEBUG(1, "IO for command started\n"); 239 gettimeofday(&cmd_max_end_time, NULL); 240 cmd_max_end_time.tv_sec += cmd_time_out; 241 cmd_started = True; 242 } 243 if (max_invoke_ms > 0) { 244 usecs = 1000 * max_invoke_ms; 245 gettimeofday(&invoke_time, NULL); 246 invoke_time.tv_sec += max_invoke_ms / 1000; 247 invoke_time.tv_usec += 1000 * (max_invoke_ms % 1000); 248 invoke_time.tv_sec += invoke_time.tv_usec / (1000 * 1000); 249 invoke_time.tv_usec = invoke_time.tv_usec % (1000 * 1000); 250 } else { 251 usecs = 0; 252 } 253 if (cmd_started) { 254 // 0 usecs here means the thread just has to check gdbserver eats 255 // the characters in <= cmd_time_out seconds. 256 // We will just wait by 1 second max at a time. 257 if (usecs == 0 || usecs > 1000 * 1000) 258 usecs = 1000 * 1000; 259 } 260 usleep(usecs); 261 262 /* If nothing happened during our sleep, let's try to wake up valgrind 263 or check for cmd time out. */ 264 if (written_by_vgdb_before_sleep == VS_written_by_vgdb 265 && seen_by_valgrind_before_sleep == VS_seen_by_valgrind 266 && VS_written_by_vgdb > VS_seen_by_valgrind) { 267 struct timeval now; 268 gettimeofday(&now, NULL); 269 DEBUG(2, 270 "after sleep " 271 "written_by_vgdb %d " 272 "seen_by_valgrind %d " 273 "invoked_written %d\n", 274 VS_written_by_vgdb, 275 VS_seen_by_valgrind, 276 invoked_written); 277 /* if the pid does not exist anymore, we better stop */ 278 if (kill(pid, 0) != 0) 279 XERROR (errno, 280 "invoke_gdbserver_in_valgrind: " 281 "check for pid %d existence failed\n", pid); 282 if (cmd_started) { 283 if (timercmp (&now, &cmd_max_end_time, >)) 284 XERROR (0, 285 "pid %d did not handle a command in %d seconds\n", 286 pid, cmd_time_out); 287 } 288 if (max_invoke_ms > 0 && timercmp (&now, &invoke_time, >=)) { 289 /* only need to wake up if the nr written has changed since 290 last invoke. */ 291 if (invoked_written != written_by_vgdb_before_sleep) { 292 if (invoker_invoke_gdbserver(pid)) { 293 /* If invoke successful, no need to invoke again 294 for the same value of written_by_vgdb_before_sleep. */ 295 invoked_written = written_by_vgdb_before_sleep; 296 } 297 } 298 } 299 } else { 300 // Something happened => restart timer check. 301 if (cmd_time_out != NEVER) { 302 DEBUG(2, "some IO was done => restart command\n"); 303 cmd_started = False; 304 } 305 } 306 } 307 pthread_cleanup_pop(0); 308 return NULL; 309 } 310 311 static 312 int open_fifo (const char* name, int flags, const char* desc) 313 { 314 int fd; 315 DEBUG(1, "opening %s %s\n", name, desc); 316 fd = open(name, flags); 317 if (fd == -1) 318 XERROR (errno, "error opening %s %s\n", name, desc); 319 320 DEBUG(1, "opened %s %s fd %d\n", name, desc, fd); 321 return fd; 322 } 323 324 /* acquire a lock on the first byte of the given fd. If not successful, 325 exits with error. 326 This allows to avoid having two vgdb speaking with the same Valgrind 327 gdbserver as this causes serious headaches to the protocol. */ 328 static 329 void acquire_lock (int fd, int valgrind_pid) 330 { 331 struct flock fl; 332 fl.l_type = F_WRLCK; 333 fl.l_whence = SEEK_SET; 334 fl.l_start = 0; 335 fl.l_len = 1; 336 if (fcntl(fd, F_SETLK, &fl) < 0) { 337 if (errno == EAGAIN || errno == EACCES) { 338 XERROR(errno, 339 "Cannot acquire lock.\n" 340 "Probably vgdb pid %d already speaks with Valgrind pid %d\n", 341 VS_vgdb_pid, 342 valgrind_pid); 343 } else { 344 XERROR(errno, "cannot acquire lock.\n"); 345 } 346 } 347 348 /* Here, we have the lock. It will be released when fd will be closed. */ 349 /* We indicate our pid to Valgrind gdbserver */ 350 if (shared32 != NULL) 351 shared32->vgdb_pid = getpid(); 352 else if (shared64 != NULL) 353 shared64->vgdb_pid = getpid(); 354 else 355 assert(0); 356 } 357 358 #define PBUFSIZ 16384 /* keep in sync with server.h */ 359 360 /* read some characters from fd. 361 Returns the nr of characters read, -1 if error. 362 desc is a string used in tracing */ 363 static 364 int read_buf (int fd, char* buf, const char* desc) 365 { 366 int nrread; 367 DEBUG(2, "reading %s\n", desc); 368 nrread = read(fd, buf, PBUFSIZ); 369 if (nrread == -1) { 370 ERROR (errno, "error reading %s\n", desc); 371 return -1; 372 } 373 buf[nrread] = '\0'; 374 DEBUG(2, "read %s %s\n", desc, buf); 375 return nrread; 376 } 377 378 /* write size bytes from buf to fd. 379 desc is a description of the action for which the write is done. 380 If notify, then add size to the shared cntr indicating to the 381 valgrind process that there is new data. 382 Returns True if write is ok, False if there was a problem. */ 383 static 384 Bool write_buf(int fd, const char* buf, int size, const char* desc, Bool notify) 385 { 386 int nrwritten; 387 int nrw; 388 DEBUG(2, "writing %s len %d %.*s notify: %d\n", desc, size, 389 size, buf, notify); 390 nrwritten = 0; 391 while (nrwritten < size) { 392 nrw = write (fd, buf+nrwritten, size - nrwritten); 393 if (nrw == -1) { 394 ERROR(errno, "error write %s\n", desc); 395 return False; 396 } 397 nrwritten = nrwritten + nrw; 398 if (notify) 399 add_written(nrw); 400 } 401 return True; 402 } 403 404 typedef enum { 405 FROM_GDB, 406 TO_GDB, 407 FROM_PID, 408 TO_PID } ConnectionKind; 409 static const int NumConnectionKind = TO_PID+1; 410 static 411 const char *ppConnectionKind (ConnectionKind con) 412 { 413 switch (con) { 414 case FROM_GDB: return "FROM_GDB"; 415 case TO_GDB: return "TO_GDB"; 416 case FROM_PID: return "FROM_PID"; 417 case TO_PID: return "TO_PID"; 418 default: return "invalid connection kind"; 419 } 420 } 421 422 static char *shared_mem; 423 424 static int from_gdb = 0; /* stdin by default, changed if --port is given. */ 425 static char *from_gdb_to_pid; /* fifo name to write gdb command to pid */ 426 /* Returns True in case read/write operations were done properly. 427 Returns False in case of error. 428 to_pid is the file descriptor to write to the process pid. */ 429 static 430 Bool read_from_gdb_write_to_pid(int to_pid) 431 { 432 char buf[PBUFSIZ+1]; // +1 for trailing \0 433 int nrread; 434 435 nrread = read_buf(from_gdb, buf, "from gdb on stdin"); 436 if (nrread <= 0) { 437 if (nrread == 0) 438 DEBUG(1, "read 0 bytes from gdb => assume exit\n"); 439 else 440 DEBUG(1, "error reading bytes from gdb\n"); 441 close (from_gdb); 442 shutting_down = True; 443 return False; 444 } 445 return write_buf(to_pid, buf, nrread, "to_pid", /* notify */ True); 446 } 447 448 static int to_gdb = 1; /* stdout by default, changed if --port is given. */ 449 static char *to_gdb_from_pid; /* fifo name to read pid replies */ 450 /* Returns True in case read/write operations were done properly. 451 Returns False in case of error. 452 from_pid is the file descriptor to read data from the process pid. */ 453 static 454 Bool read_from_pid_write_to_gdb(int from_pid) 455 { 456 char buf[PBUFSIZ+1]; // +1 for trailing \0 457 int nrread; 458 459 nrread = read_buf(from_pid, buf, "from pid"); 460 if (nrread <= 0) { 461 if (nrread == 0) 462 DEBUG(1, "read 0 bytes from pid => assume exit\n"); 463 else 464 DEBUG(1, "error reading bytes from pid\n"); 465 close (from_pid); 466 shutting_down = True; 467 return False; 468 } 469 return write_buf(to_gdb, buf, nrread, "to_gdb", /* notify */ False); 470 } 471 472 static 473 void wait_for_gdb_connect (int in_port) 474 { 475 struct sockaddr_in addr; 476 477 int listen_gdb = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); 478 int gdb_connect; 479 480 if (-1 == listen_gdb) { 481 XERROR(errno, "cannot create socket"); 482 } 483 484 memset(&addr, 0, sizeof(addr)); 485 486 addr.sin_family = AF_INET; 487 addr.sin_port = htons((unsigned short int)in_port); 488 addr.sin_addr.s_addr = INADDR_ANY; 489 490 if (-1 == bind(listen_gdb,(struct sockaddr *)&addr, sizeof(addr))) { 491 XERROR(errno, "bind failed"); 492 } 493 fprintf(stderr, "listening on port %d ...", in_port); 494 fflush(stderr); 495 if (-1 == listen(listen_gdb, 1)) { 496 XERROR(errno, "error listen failed"); 497 } 498 499 gdb_connect = accept(listen_gdb, NULL, NULL); 500 if (gdb_connect < 0) { 501 XERROR(errno, "accept failed"); 502 } 503 fprintf(stderr, "connected.\n"); 504 fflush(stderr); 505 close(listen_gdb); 506 from_gdb = gdb_connect; 507 to_gdb = gdb_connect; 508 } 509 510 /* prepares the FIFOs filenames, map the shared memory. */ 511 static 512 void prepare_fifos_and_shared_mem(int pid) 513 { 514 const HChar *user, *host; 515 unsigned len; 516 517 user = getenv("LOGNAME"); 518 if (user == NULL) user = getenv("USER"); 519 if (user == NULL) user = "???"; 520 if (strchr(user, '/')) user = "???"; 521 522 host = getenv("HOST"); 523 if (host == NULL) host = getenv("HOSTNAME"); 524 if (host == NULL) host = "???"; 525 if (strchr(host, '/')) host = "???"; 526 527 len = strlen(vgdb_prefix) + strlen(user) + strlen(host) + 40; 528 from_gdb_to_pid = vmalloc (len); 529 to_gdb_from_pid = vmalloc (len); 530 shared_mem = vmalloc (len); 531 /* below 3 lines must match the equivalent in remote-utils.c */ 532 sprintf(from_gdb_to_pid, "%s-from-vgdb-to-%d-by-%s-on-%s", vgdb_prefix, 533 pid, user, host); 534 sprintf(to_gdb_from_pid, "%s-to-vgdb-from-%d-by-%s-on-%s", vgdb_prefix, 535 pid, user, host); 536 sprintf(shared_mem, "%s-shared-mem-vgdb-%d-by-%s-on-%s", vgdb_prefix, 537 pid, user, host); 538 DEBUG (1, "vgdb: using %s %s %s\n", 539 from_gdb_to_pid, to_gdb_from_pid, shared_mem); 540 541 map_vgdbshared(shared_mem); 542 } 543 544 /* Convert hex digit A to a number. */ 545 546 static int 547 fromhex (int a) 548 { 549 if (a >= '0' && a <= '9') 550 return a - '0'; 551 else if (a >= 'a' && a <= 'f') 552 return a - 'a' + 10; 553 else 554 XERROR(0, "Reply contains invalid hex digit %c\n", a); 555 return 0; 556 } 557 558 /* Returns next char from fd. -1 if error, -2 if EOF. 559 NB: must always call it with the same fd */ 560 static int 561 readchar (int fd) 562 { 563 static char buf[PBUFSIZ+1]; // +1 for trailing \0 564 static int bufcnt = 0; 565 static unsigned char *bufp; 566 // unsigned bufp to e.g. avoid having 255 converted to int -1 567 568 if (bufcnt-- > 0) 569 return *bufp++; 570 571 bufcnt = read_buf (fd, buf, "static buf readchar"); 572 573 if (bufcnt <= 0) { 574 if (bufcnt == 0) { 575 fprintf (stderr, "readchar: Got EOF\n"); 576 return -2; 577 } else { 578 ERROR (errno, "readchar\n"); 579 return -1; 580 } 581 } 582 583 bufp = (unsigned char *)buf; 584 bufcnt--; 585 return *bufp++; 586 } 587 588 /* Read a packet from fromfd, with error checking, 589 and store it in BUF. 590 If checksum incorrect, writes a - on ackfd. 591 Returns length of packet, or -1 if error or -2 if EOF. */ 592 static int 593 getpkt (char *buf, int fromfd, int ackfd) 594 { 595 char *bp; 596 unsigned char csum, c1, c2; 597 int c; 598 599 while (1) { 600 csum = 0; 601 602 while (1) { 603 c = readchar (fromfd); 604 if (c == '$') 605 break; 606 DEBUG(2, "[getpkt: discarding char '%c']\n", c); 607 if (c < 0) 608 return c; 609 } 610 611 bp = buf; 612 while (1) { 613 c = readchar (fromfd); 614 if (c < 0) 615 return c; 616 if (c == '#') 617 break; 618 if (c == '*') { 619 int repeat; 620 int r; 621 int prev; 622 prev = *(bp-1); 623 csum += c; 624 repeat = readchar (fromfd); 625 csum += repeat; 626 for (r = 0; r < repeat - 29; r ++) 627 *bp++ = prev; 628 } else { 629 *bp++ = c; 630 csum += c; 631 } 632 } 633 *bp = 0; 634 635 c1 = fromhex (readchar (fromfd)); 636 c2 = fromhex (readchar (fromfd)); 637 638 if (csum == (c1 << 4) + c2) 639 break; 640 641 fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n", 642 (c1 << 4) + c2, csum, buf); 643 if (write (ackfd, "-", 1) != 1) 644 ERROR(0, "error when writing - (nack)\n"); 645 else 646 add_written(1); 647 } 648 649 DEBUG(2, "getpkt (\"%s\"); [no ack] \n", buf); 650 return bp - buf; 651 } 652 653 static int sigint = 0; 654 static int sigterm = 0; 655 static int sigpipe = 0; 656 static int sighup = 0; 657 static int sigusr1 = 0; 658 static int sigalrm = 0; 659 static int sigusr1_fd = -1; 660 static pthread_t invoke_gdbserver_in_valgrind_thread; 661 662 static 663 void received_signal (int signum) 664 { 665 if (signum == SIGINT) 666 sigint++; 667 else if (signum == SIGUSR1) { 668 sigusr1++; 669 if (sigusr1_fd >= 0) { 670 char control_c = '\003'; 671 write_buf(sigusr1_fd, &control_c, 1, 672 "write \\003 on SIGUSR1", /* notify */ True); 673 } 674 } 675 else if (signum == SIGTERM) { 676 shutting_down = True; 677 sigterm++; 678 } else if (signum == SIGHUP) { 679 shutting_down = True; 680 sighup++; 681 } else if (signum == SIGPIPE) { 682 sigpipe++; 683 } else if (signum == SIGALRM) { 684 sigalrm++; 685 #if defined(__BIONIC__) 686 /* Android has no pthread_cancel. As it also does not have 687 an invoker implementation, there is no need for cleanup action. 688 So, we just do nothing. */ 689 DEBUG(1, "sigalrm received, no action on android\n"); 690 #else 691 /* Note: we cannot directly invoke restore_and_detach : this must 692 be done by the thread that has attached. 693 We have in this thread pushed a cleanup handler that will 694 cleanup what is needed. */ 695 DEBUG(1, "pthread_cancel invoke_gdbserver_in_valgrind_thread\n"); 696 pthread_cancel(invoke_gdbserver_in_valgrind_thread); 697 #endif 698 } else { 699 ERROR(0, "unexpected signal %d\n", signum); 700 } 701 } 702 703 /* install the signal handlers allowing e.g. vgdb to cleanup in 704 case of termination. */ 705 static 706 void install_handlers(void) 707 { 708 struct sigaction action, oldaction; 709 710 action.sa_handler = received_signal; 711 sigemptyset (&action.sa_mask); 712 action.sa_flags = 0; 713 714 /* SIGINT: when user types C-c in gdb, this sends 715 a SIGINT to vgdb + causes a character to be sent to remote gdbserver. 716 The later is enough to wakeup the valgrind process. */ 717 if (sigaction (SIGINT, &action, &oldaction) != 0) 718 XERROR (errno, "vgdb error sigaction SIGINT\n"); 719 /* We might do something more intelligent than just 720 reporting this SIGINT E.g. behave similarly to the gdb: two 721 control-C without feedback from the debugged process would 722 mean to stop debugging it. */ 723 724 /* SIGUSR1: this is used to facilitate automatic testing. When 725 vgdb receives this signal, it will simulate the user typing C-c. */ 726 if (sigaction (SIGUSR1, &action, &oldaction) != 0) 727 XERROR (errno, "vgdb error sigaction SIGUSR1\n"); 728 729 730 /* SIGTERM: can receive this signal (e.g. from gdb) to terminate vgdb 731 when detaching or similar. A clean shutdown will be done as both 732 the read and write side will detect an end of file. */ 733 if (sigaction (SIGTERM, &action, &oldaction) != 0) 734 XERROR (errno, "vgdb error sigaction SIGTERM\n"); 735 736 /* SIGPIPE: can receive this signal when gdb detaches or kill the 737 process debugged: gdb will close its pipes to vgdb. vgdb 738 must resist to this signal to allow a clean shutdown. */ 739 if (sigaction (SIGPIPE, &action, &oldaction) != 0) 740 XERROR (errno, "vgdb error sigaction SIGPIPE\n"); 741 742 /* SIGALRM: in case invoke thread is blocked, alarm is used 743 to cleanup. */ 744 if (sigaction (SIGALRM, &action, &oldaction) != 0) 745 XERROR (errno, "vgdb error sigaction SIGALRM\n"); 746 747 /* unmask all signals, in case the process that launched vgdb 748 masked some. */ 749 if (sigprocmask (SIG_SETMASK, &action.sa_mask, NULL) != 0) 750 XERROR (errno, "vgdb error sigprocmask"); 751 } 752 753 /* close the FIFOs provided connections, terminate the invoker thread. */ 754 static 755 void close_connection(int to_pid, int from_pid) 756 { 757 DEBUG(1, "nr received signals: sigint %d sigterm %d sighup %d sigpipe %d\n", 758 sigint, sigterm, sighup, sigpipe); 759 /* Note that we do not forward sigterm to the valgrind process: 760 a sigterm signal is (probably) received from gdb if the user wants to 761 kill the debugged process. The kill instruction has been given to 762 the valgrind process, which should execute a clean exit. */ 763 764 /* We first close the connection to pid. The pid will then 765 terminates its gdbserver work. We keep the from pid 766 fifo opened till the invoker thread is finished. 767 This allows the gdbserver to finish sending its last reply. */ 768 if (close(to_pid) != 0) 769 ERROR(errno, "close to_pid\n"); 770 771 /* if there is a task that was busy trying to wake up valgrind 772 process, we wait for it to be terminated otherwise threads 773 in the valgrind process can stay stopped if vgdb main 774 exits before the invoke thread had time to detach from 775 all valgrind threads. */ 776 if (max_invoke_ms > 0 || cmd_time_out != NEVER) { 777 int join; 778 779 /* It is surprisingly complex to properly shutdown or exit the 780 valgrind process in which gdbserver has been invoked through 781 ptrace. In the normal case (gdb detaches from the process, 782 or process is continued), the valgrind process will reach the 783 breakpoint place. Using ptrace, vgdb will ensure the 784 previous activity of the process is resumed (e.g. restart a 785 blocking system call). The special case is when gdb asks the 786 valgrind process to exit (using either the "kill" command or 787 "monitor exit"). In such a case, the valgrind process will 788 call exit. But a ptraced process will be blocked in exit, 789 waiting for the ptracing process to detach or die. vgdb 790 cannot detach unconditionally as otherwise, in the normal 791 case, the valgrind process would stop abnormally with SIGSTOP 792 (as vgdb would not be there to catch it). vgdb can also not 793 die unconditionally otherwise again, similar problem. So, we 794 assume that most of the time, we arrive here in the normal 795 case, and so, the breakpoint has been encountered by the 796 valgrind process, so the invoker thread will exit and the 797 join will succeed. For the "kill" case, we cause an alarm 798 signal to be sent after a few seconds. This means that in the 799 normal case, the gdbserver code in valgrind process must have 800 returned the control in less than the alarm nr of seconds, 801 otherwise, valgrind will stop abnormally with SIGSTOP. */ 802 (void) alarm (3); 803 804 DEBUG(1, "joining with invoke_gdbserver_in_valgrind_thread\n"); 805 join = pthread_join(invoke_gdbserver_in_valgrind_thread, NULL); 806 if (join != 0) 807 XERROR 808 (join, 809 "vgdb error pthread_join invoke_gdbserver_in_valgrind_thread\n"); 810 } 811 if (close(from_pid) != 0) 812 ERROR(errno, "close from_pid\n"); 813 } 814 815 /* Relay data between gdb and Valgrind gdbserver, till EOF or an 816 error is encountered. */ 817 static 818 void gdb_relay (int pid) 819 { 820 int from_pid = -1; /* fd to read from pid */ 821 int to_pid = -1; /* fd to write to pid */ 822 823 int shutdown_loop = 0; 824 fprintf (stderr, "relaying data between gdb and process %d\n", pid); 825 fflush (stderr); 826 827 if (max_invoke_ms > 0) 828 pthread_create(&invoke_gdbserver_in_valgrind_thread, NULL, 829 invoke_gdbserver_in_valgrind, (void *) &pid); 830 to_pid = open_fifo(from_gdb_to_pid, O_WRONLY, "write to pid"); 831 acquire_lock (shared_mem_fd, pid); 832 833 from_pid = open_fifo (to_gdb_from_pid, O_RDONLY|O_NONBLOCK, 834 "read mode from pid"); 835 836 sigusr1_fd = to_pid; /* allow simulating user typing control-c */ 837 838 while (1) { 839 ConnectionKind ck; 840 int ret; 841 struct pollfd pollfds[NumConnectionKind]; 842 843 /* watch data written by gdb, watch POLLERR on both gdb fd */ 844 pollfds[FROM_GDB].fd = from_gdb; 845 pollfds[FROM_GDB].events = POLLIN; 846 pollfds[FROM_GDB].revents = 0; 847 pollfds[TO_GDB].fd = to_gdb; 848 pollfds[TO_GDB].events = 0; 849 pollfds[TO_GDB].revents = 0; 850 851 /* watch data written by pid, watch POLLERR on both pid fd */ 852 pollfds[FROM_PID].fd = from_pid; 853 pollfds[FROM_PID].events = POLLIN; 854 pollfds[FROM_PID].revents = 0; 855 pollfds[TO_PID].fd = to_pid; 856 pollfds[TO_PID].events = 0; 857 pollfds[TO_PID].revents = 0; 858 859 ret = poll(pollfds, 860 NumConnectionKind, 861 (shutting_down ? 862 1 /* one second */ 863 : -1 /* infinite */)); 864 DEBUG(2, "poll ret %d errno %d\n", ret, errno); 865 866 /* check for unexpected error */ 867 if (ret <= 0 && errno != EINTR) { 868 ERROR (errno, "unexpected poll ret %d\n", ret); 869 shutting_down = True; 870 break; 871 } 872 873 /* check for data to read */ 874 for (ck = 0; ck < NumConnectionKind; ck ++) { 875 if (pollfds[ck].revents & POLLIN) { 876 switch (ck) { 877 case FROM_GDB: 878 if (!read_from_gdb_write_to_pid(to_pid)) 879 shutting_down = True; 880 break; 881 case FROM_PID: 882 if (!read_from_pid_write_to_gdb(from_pid)) 883 shutting_down = True; 884 break; 885 default: XERROR(0, "unexpected POLLIN on %s\n", 886 ppConnectionKind(ck)); 887 } 888 } 889 } 890 891 /* check for an fd being in error condition */ 892 for (ck = 0; ck < NumConnectionKind; ck ++) { 893 if (pollfds[ck].revents & POLLERR) { 894 DEBUG(1, "connection %s fd %d POLLERR error condition\n", 895 ppConnectionKind(ck), pollfds[ck].fd); 896 invoker_valgrind_dying(); 897 shutting_down = True; 898 } 899 if (pollfds[ck].revents & POLLHUP) { 900 DEBUG(1, "connection %s fd %d POLLHUP error condition\n", 901 ppConnectionKind(ck), pollfds[ck].fd); 902 invoker_valgrind_dying(); 903 shutting_down = True; 904 } 905 if (pollfds[ck].revents & POLLNVAL) { 906 DEBUG(1, "connection %s fd %d POLLNVAL error condition\n", 907 ppConnectionKind(ck), pollfds[ck].fd); 908 invoker_valgrind_dying(); 909 shutting_down = True; 910 } 911 } 912 913 if (shutting_down) { 914 /* we let some time to the final packets to be transferred */ 915 shutdown_loop++; 916 if (shutdown_loop > 3) 917 break; 918 } 919 } 920 close_connection(to_pid, from_pid); 921 } 922 923 static int packet_len_for_command(char *cmd) 924 { 925 /* cmd will be send as a packet $qRcmd,xxxx....................xx#cc */ 926 return 7+ 2*strlen(cmd) +3 + 1; 927 } 928 929 /* hyper-minimal protocol implementation that 930 sends the provided commands (using qRcmd packets) 931 and read and display their replies. */ 932 static 933 void standalone_send_commands(int pid, 934 int last_command, 935 char *commands[] ) 936 { 937 int from_pid = -1; /* fd to read from pid */ 938 int to_pid = -1; /* fd to write to pid */ 939 940 int i; 941 int hi; 942 char hex[3]; 943 unsigned char cksum; 944 char *hexcommand; 945 char buf[PBUFSIZ+1]; // +1 for trailing \0 946 int buflen; 947 int nc; 948 949 950 if (max_invoke_ms > 0 || cmd_time_out != NEVER) 951 pthread_create(&invoke_gdbserver_in_valgrind_thread, NULL, 952 invoke_gdbserver_in_valgrind, (void *) &pid); 953 954 to_pid = open_fifo(from_gdb_to_pid, O_WRONLY, "write to pid"); 955 acquire_lock (shared_mem_fd, pid); 956 957 /* first send a C-c \003 to pid, so that it wakes up the process 958 After that, we can open the fifo from the pid in read mode 959 We then start to wait for packets (normally first a resume reply) 960 At that point, we send our command and expect replies */ 961 buf[0] = '\003'; 962 i = 0; 963 while (!write_buf(to_pid, buf, 1, 964 "write \\003 to wake up", /* notify */ True)) { 965 /* If write fails, retries up to 10 times every 0.5 seconds 966 This aims at solving the race condition described in 967 remote-utils.c remote_finish function. */ 968 usleep(500*1000); 969 i++; 970 if (i >= 10) 971 XERROR (errno, "failed to send wake up char after 10 trials\n"); 972 } 973 from_pid = open_fifo(to_gdb_from_pid, O_RDONLY, 974 "read cmd result from pid"); 975 976 /* Enable no ack mode. */ 977 write_buf(to_pid, "$QStartNoAckMode#b0", 19, "write start no ack mode", 978 /* notify */ True); 979 buflen = getpkt(buf, from_pid, to_pid); 980 if (buflen != 2 || strcmp(buf, "OK") != 0) { 981 if (buflen != 2) 982 ERROR (0, "no ack mode: unexpected buflen %d\n", buflen); 983 else 984 ERROR (0, "no ack mode: unexpected packet %s\n", buf); 985 } 986 987 for (nc = 0; nc <= last_command; nc++) { 988 fprintf (stderr, "sending command %s to pid %d\n", commands[nc], pid); 989 fflush (stderr); 990 991 /* prepare hexcommand $qRcmd,xxxx....................xx#cc */ 992 hexcommand = vmalloc (packet_len_for_command(commands[nc])); 993 hexcommand[0] = 0; 994 strcat (hexcommand, "$qRcmd,"); 995 for (i = 0; i < strlen(commands[nc]); i++) { 996 sprintf(hex, "%02x", (unsigned char) commands[nc][i]); 997 // Need to use unsigned char, to avoid sign extension. 998 strcat (hexcommand, hex); 999 } 1000 /* checksum (but without the $) */ 1001 cksum = 0; 1002 for (hi = 1; hi < strlen(hexcommand); hi++) 1003 cksum+=hexcommand[hi]; 1004 strcat(hexcommand, "#"); 1005 sprintf(hex, "%02x", cksum); 1006 strcat(hexcommand, hex); 1007 write_buf(to_pid, hexcommand, strlen(hexcommand), 1008 "writing hex command to pid", /* notify */ True); 1009 1010 /* we exit of the below loop explicitly when the command has 1011 been handled or because a signal handler will set 1012 shutting_down. */ 1013 while (!shutting_down) { 1014 buflen = getpkt(buf, from_pid, to_pid); 1015 if (buflen < 0) { 1016 ERROR (0, "error reading packet\n"); 1017 if (buflen == -2) 1018 invoker_valgrind_dying(); 1019 break; 1020 } 1021 if (strlen(buf) == 0) { 1022 DEBUG(0, "empty packet rcvd (packet qRcmd not recognised?)\n"); 1023 break; 1024 } 1025 if (strcmp(buf, "OK") == 0) { 1026 DEBUG(1, "OK packet rcvd\n"); 1027 break; 1028 } 1029 if (buf[0] == 'E') { 1030 DEBUG(0, 1031 "E NN error packet rcvd: %s (unknown monitor command?)\n", 1032 buf); 1033 break; 1034 } 1035 if (buf[0] == 'W') { 1036 DEBUG(0, "W stopped packet rcvd: %s\n", buf); 1037 break; 1038 } 1039 if (buf[0] == 'T') { 1040 DEBUG(1, "T resume reply packet received: %s\n", buf); 1041 continue; 1042 } 1043 1044 /* must be here an O packet with hex encoded string reply 1045 => decode and print it */ 1046 if (buf[0] != 'O') { 1047 DEBUG(0, "expecting O packet, received: %s\n", buf); 1048 continue; 1049 } 1050 { 1051 char buf_print[buflen/2 + 1]; 1052 for (i = 1; i < buflen; i = i + 2) 1053 buf_print[i/2] = (fromhex(*(buf+i)) << 4) 1054 + fromhex(*(buf+i+1)); 1055 buf_print[buflen/2] = 0; 1056 printf("%s", buf_print); 1057 fflush(stdout); 1058 } 1059 } 1060 free (hexcommand); 1061 } 1062 shutting_down = True; 1063 1064 close_connection(to_pid, from_pid); 1065 } 1066 1067 /* report to user the existence of a vgdb-able valgrind process 1068 with given pid. 1069 Note: this function does not use XERROR if an error is encountered 1070 while producing the command line for pid, as this is not critical 1071 and at least on MacOS, reading cmdline is not available. */ 1072 static 1073 void report_pid (int pid, Bool on_stdout) 1074 { 1075 char cmdline_file[50]; // large enough 1076 int fd, i; 1077 FILE *out = on_stdout ? stdout : stderr; 1078 1079 fprintf(out, "use --pid=%d for ", pid); 1080 1081 sprintf(cmdline_file, "/proc/%d/cmdline", pid); 1082 fd = open (cmdline_file, O_RDONLY); 1083 if (fd == -1) { 1084 DEBUG(1, "error opening cmdline file %s %s\n", 1085 cmdline_file, strerror(errno)); 1086 fprintf(out, "(could not open process command line)\n"); 1087 } else { 1088 char cmdline[100]; 1089 ssize_t sz; 1090 while ((sz = read(fd, cmdline, sizeof cmdline - 1)) != 0) { 1091 for (i = 0; i < sz; i++) 1092 if (cmdline[i] == 0) 1093 cmdline[i] = ' '; 1094 cmdline[sz] = 0; 1095 fprintf(out, "%s", cmdline); 1096 } 1097 if (sz == -1) { 1098 DEBUG(1, "error reading cmdline file %s %s\n", 1099 cmdline_file, strerror(errno)); 1100 fprintf(out, "(error reading process command line)"); 1101 } 1102 fprintf(out, "\n"); 1103 close (fd); 1104 } 1105 fflush(out); 1106 } 1107 1108 static 1109 void usage(void) 1110 { 1111 fprintf(stderr, 1112 "Usage: vgdb [OPTION]... [[-c] COMMAND]...\n" 1113 "vgdb (valgrind gdb) has two usages\n" 1114 " 1. standalone to send monitor commands to a Valgrind gdbserver.\n" 1115 " The OPTION(s) must be followed by the command to send\n" 1116 " To send more than one command, separate the commands with -c\n" 1117 " 2. relay application between gdb and a Valgrind gdbserver.\n" 1118 " Only OPTION(s) can be given.\n" 1119 "\n" 1120 " OPTIONS are [--pid=<number>] [--vgdb-prefix=<prefix>]\n" 1121 " [--wait=<number>] [--max-invoke-ms=<number>]\n" 1122 " [--port=<portnr>\n" 1123 " [--cmd-time-out=<number>] [-l] [-D] [-d]\n" 1124 " \n" 1125 " --pid arg must be given if multiple Valgrind gdbservers are found.\n" 1126 " --vgdb-prefix arg must be given to both Valgrind and vgdb utility\n" 1127 " if you want to change the prefix (default %s) for the FIFOs communication\n" 1128 " between the Valgrind gdbserver and vgdb.\n" 1129 " --wait (default 0) tells vgdb to check during the specified number\n" 1130 " of seconds if a Valgrind gdbserver can be found.\n" 1131 " --max-invoke-ms (default 100) gives the nr of milli-seconds after which vgdb\n" 1132 " will force the invocation of the Valgrind gdbserver (if the Valgrind\n" 1133 " process is blocked in a system call).\n" 1134 " --port instructs vgdb to listen for gdb on the specified port nr.\n" 1135 " --cmd-time-out (default 99999999) tells vgdb to exit if the found Valgrind\n" 1136 " gdbserver has not processed a command after number seconds\n" 1137 " -l arg tells to show the list of running Valgrind gdbserver and then exit.\n" 1138 " -D arg tells to show shared mem status and then exit.\n" 1139 " -d arg tells to show debug info. Multiple -d args for more debug info\n" 1140 "\n" 1141 " -h --help shows this message\n" 1142 " To get help from the Valgrind gdbserver, use vgdb help\n" 1143 "\n", vgdb_prefix_default() 1144 ); 1145 invoker_restrictions_msg(); 1146 } 1147 1148 /* If show_list, outputs on stdout the list of Valgrind processes with gdbserver activated. 1149 and then exits. 1150 1151 else if arg_pid == -1, waits maximum check_trials seconds to discover 1152 a valgrind pid appearing. 1153 1154 Otherwise verify arg_pid is valid and corresponds to a Valgrind process 1155 with gdbserver activated. 1156 1157 Returns the pid to work with 1158 or exits in case of error (e.g. no pid found corresponding to arg_pid */ 1159 1160 static 1161 int search_arg_pid(int arg_pid, int check_trials, Bool show_list) 1162 { 1163 int i; 1164 int pid = -1; 1165 1166 if (arg_pid == 0 || arg_pid < -1) { 1167 fprintf (stderr, "vgdb error: invalid pid %d given\n", arg_pid); 1168 exit (1); 1169 } else { 1170 /* search for a matching named fifo. 1171 If we have been given a pid, we will check that the matching FIFO is 1172 there (or wait the nr of check_trials for this to appear). 1173 If no pid has been given, then if we find only one FIFO, 1174 we will use this to build the pid to use. 1175 If we find multiple processes with valid FIFO, we report them and will 1176 exit with an error. */ 1177 DIR *vgdb_dir; 1178 char *vgdb_dir_name = vmalloc (strlen (vgdb_prefix) + 3); 1179 struct dirent *f; 1180 int is; 1181 int nr_valid_pid = 0; 1182 const char *suffix = "-from-vgdb-to-"; /* followed by pid */ 1183 char *vgdb_format = vmalloc (strlen(vgdb_prefix) + strlen(suffix) + 1); 1184 1185 strcpy (vgdb_format, vgdb_prefix); 1186 strcat (vgdb_format, suffix); 1187 1188 if (strchr(vgdb_prefix, '/') != NULL) { 1189 strcpy (vgdb_dir_name, vgdb_prefix); 1190 for (is = strlen(vgdb_prefix) - 1; is >= 0; is--) 1191 if (vgdb_dir_name[is] == '/') { 1192 vgdb_dir_name[is+1] = '\0'; 1193 break; 1194 } 1195 } else { 1196 strcpy (vgdb_dir_name, ""); 1197 } 1198 1199 DEBUG(1, "searching pid in directory %s format %s\n", 1200 vgdb_dir_name, vgdb_format); 1201 1202 /* try to find FIFOs with valid pid. 1203 On exit of the loop, pid is set to: 1204 the last pid found if show_list (or -1 if no process was listed) 1205 -1 if no FIFOs matching a running process is found 1206 -2 if multiple FIFOs of running processes are found 1207 otherwise it is set to the (only) pid found that can be debugged 1208 */ 1209 for (i = 0; i < check_trials; i++) { 1210 DEBUG(1, "check_trial %d \n", i); 1211 if (i > 0) 1212 /* wait one second before checking again */ 1213 sleep(1); 1214 1215 vgdb_dir = opendir (strlen (vgdb_dir_name) ? vgdb_dir_name : "./"); 1216 if (vgdb_dir == NULL) 1217 XERROR (errno, 1218 "vgdb error: opening directory %s searching vgdb fifo\n", 1219 vgdb_dir_name); 1220 1221 errno = 0; /* avoid complain if vgdb_dir is empty */ 1222 while ((f = readdir (vgdb_dir))) { 1223 struct stat st; 1224 char pathname[strlen(vgdb_dir_name) + strlen(f->d_name) + 1]; 1225 char *wrongpid; 1226 int newpid; 1227 1228 strcpy (pathname, vgdb_dir_name); 1229 strcat (pathname, f->d_name); 1230 DEBUG(3, "checking pathname is FIFO %s\n", pathname); 1231 if (stat (pathname, &st) != 0) { 1232 if (debuglevel >= 3) 1233 ERROR (errno, "vgdb error: stat %s searching vgdb fifo\n", 1234 pathname); 1235 } else if (S_ISFIFO (st.st_mode)) { 1236 DEBUG(3, "trying FIFO %s\n", pathname); 1237 if (strncmp (pathname, vgdb_format, 1238 strlen (vgdb_format)) == 0) { 1239 newpid = strtol(pathname + strlen (vgdb_format), 1240 &wrongpid, 10); 1241 if (*wrongpid == '-' && newpid > 0 1242 && kill (newpid, 0) == 0) { 1243 nr_valid_pid++; 1244 if (show_list) { 1245 report_pid (newpid, /*on_stdout*/ True); 1246 pid = newpid; 1247 } else if (arg_pid != -1) { 1248 if (arg_pid == newpid) { 1249 pid = newpid; 1250 } 1251 } else if (nr_valid_pid > 1) { 1252 if (nr_valid_pid == 2) { 1253 fprintf 1254 (stderr, 1255 "no --pid= arg given" 1256 " and multiple valgrind pids found:\n"); 1257 report_pid (pid, /*on_stdout*/ False); 1258 } 1259 pid = -2; 1260 report_pid (newpid, /*on_stdout*/ False); 1261 } else { 1262 pid = newpid; 1263 } 1264 } 1265 } 1266 } 1267 errno = 0; /* avoid complain if at the end of vgdb_dir */ 1268 } 1269 if (f == NULL && errno != 0) 1270 XERROR (errno, "vgdb error: reading directory %s for vgdb fifo\n", 1271 vgdb_dir_name); 1272 1273 closedir (vgdb_dir); 1274 if (pid != -1) 1275 break; 1276 } 1277 1278 free (vgdb_dir_name); 1279 free (vgdb_format); 1280 } 1281 1282 if (show_list) { 1283 exit (1); 1284 } else if (pid == -1) { 1285 if (arg_pid == -1) 1286 fprintf (stderr, "vgdb error: no FIFO found and no pid given\n"); 1287 else 1288 fprintf (stderr, "vgdb error: no FIFO found matching pid %d\n", 1289 arg_pid); 1290 exit (1); 1291 } 1292 else if (pid == -2) { 1293 /* no arg_pid given, multiple FIFOs found */ 1294 exit (1); 1295 } 1296 else { 1297 return pid; 1298 } 1299 } 1300 1301 /* return true if the numeric value of an option of the 1302 form --xxxxxxxxx=<number> could properly be extracted 1303 from arg. If True is returned, *value contains the 1304 extracted value.*/ 1305 static 1306 Bool numeric_val(char* arg, int *value) 1307 { 1308 const char *eq_pos = strchr(arg, '='); 1309 char *wrong; 1310 long long int long_value; 1311 1312 if (eq_pos == NULL) 1313 return False; 1314 1315 long_value = strtoll(eq_pos+1, &wrong, 10); 1316 if (long_value < 0 || long_value > INT_MAX) 1317 return False; 1318 if (*wrong) 1319 return False; 1320 1321 *value = (int) long_value; 1322 return True; 1323 } 1324 1325 /* true if arg matches the provided option */ 1326 static 1327 Bool is_opt(char* arg, const char *option) 1328 { 1329 int option_len = strlen(option); 1330 if (option[option_len-1] == '=') 1331 return (0 == strncmp(option, arg, option_len)); 1332 else 1333 return (0 == strcmp(option, arg)); 1334 } 1335 1336 /* Parse command lines options. If error(s), exits. 1337 Otherwise returns the options in *p_... args. 1338 commands must be big enough for the commands extracted from argv. 1339 On return, *p_last_command gives the position in commands where 1340 the last command has been allocated (using vmalloc). */ 1341 static 1342 void parse_options(int argc, char** argv, 1343 Bool *p_show_shared_mem, 1344 Bool *p_show_list, 1345 int *p_arg_pid, 1346 int *p_check_trials, 1347 int *p_port, 1348 int *p_last_command, 1349 char *commands[]) 1350 { 1351 Bool show_shared_mem = False; 1352 Bool show_list = False; 1353 int arg_pid = -1; 1354 int check_trials = 1; 1355 int last_command = -1; 1356 int int_port = 0; 1357 1358 int i; 1359 int arg_errors = 0; 1360 1361 for (i = 1; i < argc; i++) { 1362 if (is_opt(argv[i], "--help") || is_opt(argv[i], "-h")) { 1363 usage(); 1364 exit(0); 1365 } else if (is_opt(argv[i], "-d")) { 1366 debuglevel++; 1367 } else if (is_opt(argv[i], "-D")) { 1368 show_shared_mem = True; 1369 } else if (is_opt(argv[i], "-l")) { 1370 show_list = True; 1371 } else if (is_opt(argv[i], "--pid=")) { 1372 int newpid; 1373 if (!numeric_val(argv[i], &newpid)) { 1374 fprintf (stderr, "invalid --pid argument %s\n", argv[i]); 1375 arg_errors++; 1376 } else if (arg_pid != -1) { 1377 fprintf (stderr, "multiple --pid arguments given\n"); 1378 arg_errors++; 1379 } else { 1380 arg_pid = newpid; 1381 } 1382 } else if (is_opt(argv[i], "--wait=")) { 1383 if (!numeric_val(argv[i], &check_trials)) { 1384 fprintf (stderr, "invalid --wait argument %s\n", argv[i]); 1385 arg_errors++; 1386 } 1387 } else if (is_opt(argv[i], "--max-invoke-ms=")) { 1388 if (!numeric_val(argv[i], &max_invoke_ms)) { 1389 fprintf (stderr, "invalid --max-invoke-ms argument %s\n", argv[i]); 1390 arg_errors++; 1391 } 1392 } else if (is_opt(argv[i], "--cmd-time-out=")) { 1393 if (!numeric_val(argv[i], &cmd_time_out)) { 1394 fprintf (stderr, "invalid --cmd-time-out argument %s\n", argv[i]); 1395 arg_errors++; 1396 } 1397 } else if (is_opt(argv[i], "--port=")) { 1398 if (!numeric_val(argv[i], &int_port)) { 1399 fprintf (stderr, "invalid --port argument %s\n", argv[i]); 1400 arg_errors++; 1401 } 1402 } else if (is_opt(argv[i], "--vgdb-prefix=")) { 1403 vgdb_prefix = argv[i] + 14; 1404 } else if (is_opt(argv[i], "-c")) { 1405 last_command++; 1406 commands[last_command] = vmalloc (1); 1407 commands[last_command][0] = '\0'; 1408 } else if (0 == strncmp(argv[i], "-", 1)) { 1409 fprintf (stderr, "unknown or invalid argument %s\n", argv[i]); 1410 arg_errors++; 1411 } else { 1412 int len; 1413 if (last_command == -1) { 1414 /* only one command, no -c command indicator */ 1415 last_command++; 1416 commands[last_command] = vmalloc (1); 1417 commands[last_command][0] = '\0'; 1418 } 1419 len = strlen(commands[last_command]); 1420 commands[last_command] = vrealloc (commands[last_command], 1421 len + 1 + strlen(argv[i]) + 1); 1422 if (len > 0) 1423 strcat (commands[last_command], " "); 1424 strcat (commands[last_command], argv[i]); 1425 if (packet_len_for_command(commands[last_command]) > PBUFSIZ) { 1426 fprintf (stderr, "command %s too long\n", commands[last_command]); 1427 arg_errors++; 1428 } 1429 1430 } 1431 } 1432 1433 if (vgdb_prefix == NULL) 1434 vgdb_prefix = vgdb_prefix_default(); 1435 1436 if (isatty(0) 1437 && !show_shared_mem 1438 && !show_list 1439 && int_port == 0 1440 && last_command == -1) { 1441 arg_errors++; 1442 fprintf (stderr, 1443 "Using vgdb standalone implies to give -D or -l or a COMMAND\n"); 1444 } 1445 1446 if (show_shared_mem && show_list) { 1447 arg_errors++; 1448 fprintf (stderr, 1449 "Can't use both -D and -l options\n"); 1450 } 1451 1452 if (max_invoke_ms > 0 1453 && cmd_time_out != NEVER 1454 && (cmd_time_out * 1000) <= max_invoke_ms) { 1455 arg_errors++; 1456 fprintf (stderr, 1457 "--max-invoke-ms must be < --cmd-time-out * 1000\n"); 1458 } 1459 1460 if (show_list && arg_pid != -1) { 1461 arg_errors++; 1462 fprintf (stderr, 1463 "Can't use both --pid and -l options\n"); 1464 } 1465 1466 if (int_port > 0 && last_command != -1) { 1467 arg_errors++; 1468 fprintf (stderr, 1469 "Can't use --port to send commands\n"); 1470 } 1471 1472 if (arg_errors > 0) { 1473 fprintf (stderr, "args error. Try `vgdb --help` for more information\n"); 1474 exit(1); 1475 } 1476 1477 *p_show_shared_mem = show_shared_mem; 1478 *p_show_list = show_list; 1479 *p_arg_pid = arg_pid; 1480 *p_check_trials = check_trials; 1481 *p_port = int_port; 1482 *p_last_command = last_command; 1483 } 1484 1485 int main(int argc, char** argv) 1486 { 1487 int i; 1488 int pid; 1489 1490 Bool show_shared_mem; 1491 Bool show_list; 1492 int arg_pid; 1493 int check_trials; 1494 int in_port; 1495 int last_command; 1496 char *commands[argc]; // we will never have more commands than args. 1497 1498 parse_options(argc, argv, 1499 &show_shared_mem, 1500 &show_list, 1501 &arg_pid, 1502 &check_trials, 1503 &in_port, 1504 &last_command, 1505 commands); 1506 1507 /* when we are working as a relay for gdb, handle some signals by 1508 only reporting them (according to debug level). Also handle these 1509 when ptrace will be used: vgdb must clean up the ptrace effect before 1510 dying. */ 1511 if (max_invoke_ms > 0 || last_command == -1) 1512 install_handlers(); 1513 1514 pid = search_arg_pid (arg_pid, check_trials, show_list); 1515 1516 prepare_fifos_and_shared_mem(pid); 1517 1518 if (in_port > 0) 1519 wait_for_gdb_connect(in_port); 1520 1521 if (show_shared_mem) { 1522 fprintf(stderr, 1523 "vgdb %d " 1524 "written_by_vgdb %d " 1525 "seen_by_valgrind %d\n" 1526 "vgdb pid %d\n", 1527 VS_vgdb_pid, 1528 VS_written_by_vgdb, 1529 VS_seen_by_valgrind, 1530 VS_vgdb_pid); 1531 exit (0); 1532 } 1533 1534 if (last_command >= 0) { 1535 standalone_send_commands(pid, last_command, commands); 1536 } else { 1537 gdb_relay(pid); 1538 } 1539 1540 1541 free (from_gdb_to_pid); 1542 free (to_gdb_from_pid); 1543 free (shared_mem); 1544 1545 for (i = 0; i <= last_command; i++) 1546 free (commands[i]); 1547 return 0; 1548 } 1549
