1/* Machine independent support for QNX Neutrino /proc (process file system) 2 for GDB. Written by Colin Burgess at QNX Software Systems Limited. 3 4 Copyright (C) 2003-2020 Free Software Foundation, Inc. 5 6 Contributed by QNX Software Systems Ltd. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23#include "defs.h" 24 25#include <fcntl.h> 26#include <spawn.h> 27#include <sys/debug.h> 28#include <sys/procfs.h> 29#include <sys/neutrino.h> 30#include <sys/syspage.h> 31#include <dirent.h> 32#include <sys/netmgr.h> 33#include <sys/auxv.h> 34 35#include "gdbcore.h" 36#include "inferior.h" 37#include "target.h" 38#include "objfiles.h" 39#include "gdbthread.h" 40#include "nto-tdep.h" 41#include "command.h" 42#include "regcache.h" 43#include "solib.h" 44#include "inf-child.h" 45#include "gdbsupport/filestuff.h" 46#include "gdbsupport/scoped_fd.h" 47 48#define NULL_PID 0 49#define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\ 50 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY) 51 52int ctl_fd; 53 54static sighandler_t ofunc; 55 56static procfs_run run; 57 58/* Create the "native" and "procfs" targets. */ 59 60struct nto_procfs_target : public inf_child_target 61{ 62 void open (const char *arg, int from_tty) override; 63 64 void attach (const char *, int) override = 0; 65 66 void post_attach (int); 67 68 void detach (inferior *, int) override; 69 70 void resume (ptid_t, int, enum gdb_signal) override; 71 72 ptid_t wait (ptid_t, struct target_waitstatus *, int) override; 73 74 void fetch_registers (struct regcache *, int) override; 75 void store_registers (struct regcache *, int) override; 76 77 enum target_xfer_status xfer_partial (enum target_object object, 78 const char *annex, 79 gdb_byte *readbuf, 80 const gdb_byte *writebuf, 81 ULONGEST offset, ULONGEST len, 82 ULONGEST *xfered_len) override; 83 84 void files_info () override; 85 86 int insert_breakpoint (struct gdbarch *, struct bp_target_info *) override; 87 88 int remove_breakpoint (struct gdbarch *, struct bp_target_info *, 89 enum remove_bp_reason) override; 90 91 int can_use_hw_breakpoint (enum bptype, int, int) override; 92 93 int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override; 94 95 int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override; 96 97 int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, 98 struct expression *) override; 99 100 int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, 101 struct expression *) override; 102 103 bool stopped_by_watchpoint () override; 104 105 void kill () override; 106 107 void create_inferior (const char *, const std::string &, 108 char **, int) override; 109 110 void mourn_inferior () override; 111 112 void pass_signals (gdb::array_view<const unsigned char>) override; 113 114 bool thread_alive (ptid_t ptid) override; 115 116 void update_thread_list () override; 117 118 std::string pid_to_str (ptid_t) override; 119 120 void interrupt () override; 121 122 const char *extra_thread_info (struct thread_info *) override; 123 124 char *pid_to_exec_file (int pid) override; 125}; 126 127/* For "target native". */ 128 129static const target_info nto_native_target_info = { 130 "native", 131 N_("QNX Neutrino local process"), 132 N_("QNX Neutrino local process (started by the \"run\" command).") 133}; 134 135class nto_procfs_target_native final : public nto_procfs_target 136{ 137 const target_info &info () const override 138 { return nto_native_target_info; } 139}; 140 141/* For "target procfs <node>". */ 142 143static const target_info nto_procfs_target_info = { 144 "procfs", 145 N_("QNX Neutrino local or remote process"), 146 N_("QNX Neutrino process. target procfs NODE") 147}; 148 149struct nto_procfs_target_procfs final : public nto_procfs_target 150{ 151 const target_info &info () const override 152 { return nto_procfs_target_info; } 153}; 154 155static ptid_t do_attach (ptid_t ptid); 156 157/* These two globals are only ever set in procfs_open_1, but are 158 referenced elsewhere. 'nto_procfs_node' is a flag used to say 159 whether we are local, or we should get the current node descriptor 160 for the remote QNX node. */ 161static char *nodestr; 162static unsigned nto_procfs_node = ND_LOCAL_NODE; 163 164/* Return the current QNX Node, or error out. This is a simple 165 wrapper for the netmgr_strtond() function. The reason this 166 is required is because QNX node descriptors are transient so 167 we have to re-acquire them every time. */ 168static unsigned 169nto_node (void) 170{ 171 unsigned node; 172 173 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 174 || nodestr == NULL) 175 return ND_LOCAL_NODE; 176 177 node = netmgr_strtond (nodestr, 0); 178 if (node == -1) 179 error (_("Lost the QNX node. Debug session probably over.")); 180 181 return (node); 182} 183 184static enum gdb_osabi 185procfs_is_nto_target (bfd *abfd) 186{ 187 return GDB_OSABI_QNXNTO; 188} 189 190/* This is called when we call 'target native' or 'target procfs 191 <arg>' from the (gdb) prompt. For QNX6 (nto), the only valid arg 192 will be a QNX node string, eg: "/net/some_node". If arg is not a 193 valid QNX node, we will default to local. */ 194void 195nto_procfs_target::open (const char *arg, int from_tty) 196{ 197 char *endstr; 198 char buffer[50]; 199 int total_size; 200 procfs_sysinfo *sysinfo; 201 char nto_procfs_path[PATH_MAX]; 202 203 /* Offer to kill previous inferiors before opening this target. */ 204 target_preopen (from_tty); 205 206 nto_is_nto_target = procfs_is_nto_target; 207 208 /* Set the default node used for spawning to this one, 209 and only override it if there is a valid arg. */ 210 211 xfree (nodestr); 212 nodestr = NULL; 213 214 nto_procfs_node = ND_LOCAL_NODE; 215 nodestr = (arg != NULL) ? xstrdup (arg) : NULL; 216 217 if (nodestr) 218 { 219 nto_procfs_node = netmgr_strtond (nodestr, &endstr); 220 if (nto_procfs_node == -1) 221 { 222 if (errno == ENOTSUP) 223 printf_filtered ("QNX Net Manager not found.\n"); 224 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr, 225 errno, safe_strerror (errno)); 226 xfree (nodestr); 227 nodestr = NULL; 228 nto_procfs_node = ND_LOCAL_NODE; 229 } 230 else if (*endstr) 231 { 232 if (*(endstr - 1) == '/') 233 *(endstr - 1) = 0; 234 else 235 *endstr = 0; 236 } 237 } 238 snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", 239 (nodestr != NULL) ? nodestr : "", "/proc"); 240 241 scoped_fd fd (open (nto_procfs_path, O_RDONLY)); 242 if (fd.get () == -1) 243 { 244 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path, errno, 245 safe_strerror (errno)); 246 error (_("Invalid procfs arg")); 247 } 248 249 sysinfo = (void *) buffer; 250 if (devctl (fd.get (), DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK) 251 { 252 printf_filtered ("Error getting size: %d (%s)\n", errno, 253 safe_strerror (errno)); 254 error (_("Devctl failed.")); 255 } 256 else 257 { 258 total_size = sysinfo->total_size; 259 sysinfo = alloca (total_size); 260 if (sysinfo == NULL) 261 { 262 printf_filtered ("Memory error: %d (%s)\n", errno, 263 safe_strerror (errno)); 264 error (_("alloca failed.")); 265 } 266 else 267 { 268 if (devctl (fd.get (), DCMD_PROC_SYSINFO, sysinfo, total_size, 0) 269 != EOK) 270 { 271 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno, 272 safe_strerror (errno)); 273 error (_("Devctl failed.")); 274 } 275 else 276 { 277 if (sysinfo->type != 278 nto_map_arch_to_cputype (gdbarch_bfd_arch_info 279 (target_gdbarch ())->arch_name)) 280 error (_("Invalid target CPU.")); 281 } 282 } 283 } 284 285 inf_child_target::open (arg, from_tty); 286 printf_filtered ("Debugging using %s\n", nto_procfs_path); 287} 288 289static void 290procfs_set_thread (ptid_t ptid) 291{ 292 pid_t tid; 293 294 tid = ptid.tid (); 295 devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0); 296} 297 298/* Return true if the thread TH is still alive. */ 299 300bool 301nto_procfs_target::thread_alive (ptid_t ptid) 302{ 303 pid_t tid; 304 pid_t pid; 305 procfs_status status; 306 int err; 307 308 tid = ptid.tid (); 309 pid = ptid.pid (); 310 311 if (kill (pid, 0) == -1) 312 return false; 313 314 status.tid = tid; 315 if ((err = devctl (ctl_fd, DCMD_PROC_TIDSTATUS, 316 &status, sizeof (status), 0)) != EOK) 317 return false; 318 319 /* Thread is alive or dead but not yet joined, 320 or dead and there is an alive (or dead unjoined) thread with 321 higher tid. 322 323 If the tid is not the same as requested, requested tid is dead. */ 324 return (status.tid == tid) && (status.state != STATE_DEAD); 325} 326 327static void 328update_thread_private_data_name (struct thread_info *new_thread, 329 const char *newname) 330{ 331 nto_thread_info *pti = get_nto_thread_info (new_thread); 332 333 gdb_assert (newname != NULL); 334 gdb_assert (new_thread != NULL); 335 336 if (pti) 337 { 338 pti = new nto_thread_info; 339 new_thread->priv.reset (pti); 340 } 341 342 pti->name = newname; 343} 344 345static void 346update_thread_private_data (struct thread_info *new_thread, 347 pthread_t tid, int state, int flags) 348{ 349 procfs_info pidinfo; 350 struct _thread_name *tn; 351 procfs_threadctl tctl; 352 353#if _NTO_VERSION > 630 354 gdb_assert (new_thread != NULL); 355 356 if (devctl (ctl_fd, DCMD_PROC_INFO, &pidinfo, 357 sizeof(pidinfo), 0) != EOK) 358 return; 359 360 memset (&tctl, 0, sizeof (tctl)); 361 tctl.cmd = _NTO_TCTL_NAME; 362 tn = (struct _thread_name *) (&tctl.data); 363 364 /* Fetch name for the given thread. */ 365 tctl.tid = tid; 366 tn->name_buf_len = sizeof (tctl.data) - sizeof (*tn); 367 tn->new_name_len = -1; /* Getting, not setting. */ 368 if (devctl (ctl_fd, DCMD_PROC_THREADCTL, &tctl, sizeof (tctl), NULL) != EOK) 369 tn->name_buf[0] = '\0'; 370 371 tn->name_buf[_NTO_THREAD_NAME_MAX] = '\0'; 372 373 update_thread_private_data_name (new_thread, tn->name_buf); 374 375 nto_thread_info *pti = get_nto_thread_info (new_thread); 376 pti->tid = tid; 377 pti->state = state; 378 pti->flags = flags; 379#endif /* _NTO_VERSION */ 380} 381 382void 383nto_procfs_target::update_thread_list () 384{ 385 procfs_status status; 386 pid_t pid; 387 ptid_t ptid; 388 pthread_t tid; 389 struct thread_info *new_thread; 390 391 if (ctl_fd == -1) 392 return; 393 394 prune_threads (); 395 396 pid = current_inferior ()->pid; 397 398 status.tid = 1; 399 400 for (tid = 1;; ++tid) 401 { 402 if (status.tid == tid 403 && (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0) 404 != EOK)) 405 break; 406 if (status.tid != tid) 407 /* The reason why this would not be equal is that devctl might have 408 returned different tid, meaning the requested tid no longer exists 409 (e.g. thread exited). */ 410 continue; 411 ptid = ptid_t (pid, 0, tid); 412 new_thread = find_thread_ptid (this, ptid); 413 if (!new_thread) 414 new_thread = add_thread (ptid); 415 update_thread_private_data (new_thread, tid, status.state, 0); 416 status.tid++; 417 } 418 return; 419} 420 421static void 422procfs_pidlist (const char *args, int from_tty) 423{ 424 struct dirent *dirp = NULL; 425 char buf[PATH_MAX]; 426 procfs_info *pidinfo = NULL; 427 procfs_debuginfo *info = NULL; 428 procfs_status *status = NULL; 429 pid_t num_threads = 0; 430 pid_t pid; 431 char name[512]; 432 char procfs_dir[PATH_MAX]; 433 434 snprintf (procfs_dir, sizeof (procfs_dir), "%s%s", 435 (nodestr != NULL) ? nodestr : "", "/proc"); 436 437 gdb_dir_up dp (opendir (procfs_dir)); 438 if (dp == NULL) 439 { 440 fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)", 441 procfs_dir, errno, safe_strerror (errno)); 442 return; 443 } 444 445 /* Start scan at first pid. */ 446 rewinddir (dp.get ()); 447 448 do 449 { 450 /* Get the right pid and procfs path for the pid. */ 451 do 452 { 453 dirp = readdir (dp.get ()); 454 if (dirp == NULL) 455 return; 456 snprintf (buf, sizeof (buf), "%s%s/%s/as", 457 (nodestr != NULL) ? nodestr : "", 458 "/proc", dirp->d_name); 459 pid = atoi (dirp->d_name); 460 } 461 while (pid == 0); 462 463 /* Open the procfs path. */ 464 scoped_fd fd (open (buf, O_RDONLY)); 465 if (fd.get () == -1) 466 { 467 fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n", 468 buf, errno, safe_strerror (errno)); 469 continue; 470 } 471 472 pidinfo = (procfs_info *) buf; 473 if (devctl (fd.get (), DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK) 474 { 475 fprintf_unfiltered (gdb_stderr, 476 "devctl DCMD_PROC_INFO failed - %d (%s)\n", 477 errno, safe_strerror (errno)); 478 break; 479 } 480 num_threads = pidinfo->num_threads; 481 482 info = (procfs_debuginfo *) buf; 483 if (devctl (fd.get (), DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) 484 != EOK) 485 strcpy (name, "unavailable"); 486 else 487 strcpy (name, info->path); 488 489 /* Collect state info on all the threads. */ 490 status = (procfs_status *) buf; 491 for (status->tid = 1; status->tid <= num_threads; status->tid++) 492 { 493 const int err 494 = devctl (fd.get (), DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0); 495 printf_filtered ("%s - %d", name, pid); 496 if (err == EOK && status->tid != 0) 497 printf_filtered ("/%d\n", status->tid); 498 else 499 { 500 printf_filtered ("\n"); 501 break; 502 } 503 } 504 } 505 while (dirp != NULL); 506} 507 508static void 509procfs_meminfo (const char *args, int from_tty) 510{ 511 procfs_mapinfo *mapinfos = NULL; 512 static int num_mapinfos = 0; 513 procfs_mapinfo *mapinfo_p, *mapinfo_p2; 514 int flags = ~0, err, num, i, j; 515 516 struct 517 { 518 procfs_debuginfo info; 519 char buff[_POSIX_PATH_MAX]; 520 } map; 521 522 struct info 523 { 524 unsigned addr; 525 unsigned size; 526 unsigned flags; 527 unsigned debug_vaddr; 528 unsigned long long offset; 529 }; 530 531 struct printinfo 532 { 533 unsigned long long ino; 534 unsigned dev; 535 struct info text; 536 struct info data; 537 char name[256]; 538 } printme; 539 540 /* Get the number of map entrys. */ 541 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num); 542 if (err != EOK) 543 { 544 printf ("failed devctl num mapinfos - %d (%s)\n", err, 545 safe_strerror (err)); 546 return; 547 } 548 549 mapinfos = XNEWVEC (procfs_mapinfo, num); 550 551 num_mapinfos = num; 552 mapinfo_p = mapinfos; 553 554 /* Fill the map entrys. */ 555 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num 556 * sizeof (procfs_mapinfo), &num); 557 if (err != EOK) 558 { 559 printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err)); 560 xfree (mapinfos); 561 return; 562 } 563 564 num = std::min (num, num_mapinfos); 565 566 /* Run through the list of mapinfos, and store the data and text info 567 so we can print it at the bottom of the loop. */ 568 for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++) 569 { 570 if (!(mapinfo_p->flags & flags)) 571 mapinfo_p->ino = 0; 572 573 if (mapinfo_p->ino == 0) /* Already visited. */ 574 continue; 575 576 map.info.vaddr = mapinfo_p->vaddr; 577 578 err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0); 579 if (err != EOK) 580 continue; 581 582 memset (&printme, 0, sizeof printme); 583 printme.dev = mapinfo_p->dev; 584 printme.ino = mapinfo_p->ino; 585 printme.text.addr = mapinfo_p->vaddr; 586 printme.text.size = mapinfo_p->size; 587 printme.text.flags = mapinfo_p->flags; 588 printme.text.offset = mapinfo_p->offset; 589 printme.text.debug_vaddr = map.info.vaddr; 590 strcpy (printme.name, map.info.path); 591 592 /* Check for matching data. */ 593 for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++) 594 { 595 if (mapinfo_p2->vaddr != mapinfo_p->vaddr 596 && mapinfo_p2->ino == mapinfo_p->ino 597 && mapinfo_p2->dev == mapinfo_p->dev) 598 { 599 map.info.vaddr = mapinfo_p2->vaddr; 600 err = 601 devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0); 602 if (err != EOK) 603 continue; 604 605 if (strcmp (map.info.path, printme.name)) 606 continue; 607 608 /* Lower debug_vaddr is always text, if necessary, swap. */ 609 if ((int) map.info.vaddr < (int) printme.text.debug_vaddr) 610 { 611 memcpy (&(printme.data), &(printme.text), 612 sizeof (printme.data)); 613 printme.text.addr = mapinfo_p2->vaddr; 614 printme.text.size = mapinfo_p2->size; 615 printme.text.flags = mapinfo_p2->flags; 616 printme.text.offset = mapinfo_p2->offset; 617 printme.text.debug_vaddr = map.info.vaddr; 618 } 619 else 620 { 621 printme.data.addr = mapinfo_p2->vaddr; 622 printme.data.size = mapinfo_p2->size; 623 printme.data.flags = mapinfo_p2->flags; 624 printme.data.offset = mapinfo_p2->offset; 625 printme.data.debug_vaddr = map.info.vaddr; 626 } 627 mapinfo_p2->ino = 0; 628 } 629 } 630 mapinfo_p->ino = 0; 631 632 printf_filtered ("%s\n", printme.name); 633 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size, 634 printme.text.addr); 635 printf_filtered ("\t\tflags=%08x\n", printme.text.flags); 636 printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr); 637 printf_filtered ("\t\toffset=%s\n", phex (printme.text.offset, 8)); 638 if (printme.data.size) 639 { 640 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size, 641 printme.data.addr); 642 printf_filtered ("\t\tflags=%08x\n", printme.data.flags); 643 printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr); 644 printf_filtered ("\t\toffset=%s\n", phex (printme.data.offset, 8)); 645 } 646 printf_filtered ("\tdev=0x%x\n", printme.dev); 647 printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino); 648 } 649 xfree (mapinfos); 650 return; 651} 652 653/* Print status information about what we're accessing. */ 654void 655nto_procfs_target::files_info () 656{ 657 struct inferior *inf = current_inferior (); 658 659 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n", 660 inf->attach_flag ? "attached" : "child", 661 target_pid_to_str (inferior_ptid).c_str (), 662 (nodestr != NULL) ? nodestr : "local node"); 663} 664 665/* Target to_pid_to_exec_file implementation. */ 666 667char * 668nto_procfs_target::pid_to_exec_file (const int pid) 669{ 670 int proc_fd; 671 static char proc_path[PATH_MAX]; 672 ssize_t rd; 673 674 /* Read exe file name. */ 675 snprintf (proc_path, sizeof (proc_path), "%s/proc/%d/exefile", 676 (nodestr != NULL) ? nodestr : "", pid); 677 proc_fd = open (proc_path, O_RDONLY); 678 if (proc_fd == -1) 679 return NULL; 680 681 rd = read (proc_fd, proc_path, sizeof (proc_path) - 1); 682 close (proc_fd); 683 if (rd <= 0) 684 { 685 proc_path[0] = '\0'; 686 return NULL; 687 } 688 proc_path[rd] = '\0'; 689 return proc_path; 690} 691 692/* Attach to process PID, then initialize for debugging it. */ 693void 694nto_procfs_target::attach (const char *args, int from_tty) 695{ 696 int pid; 697 struct inferior *inf; 698 699 pid = parse_pid_to_attach (args); 700 701 if (pid == getpid ()) 702 error (_("Attaching GDB to itself is not a good idea...")); 703 704 if (from_tty) 705 { 706 const char *exec_file = get_exec_file (0); 707 708 if (exec_file) 709 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file, 710 target_pid_to_str (ptid_t (pid)).c_str ()); 711 else 712 printf_unfiltered ("Attaching to %s\n", 713 target_pid_to_str (ptid_t (pid)).c_str ()); 714 } 715 ptid_t ptid = do_attach (ptid_t (pid)); 716 inf = current_inferior (); 717 inferior_appeared (inf, pid); 718 inf->attach_flag = 1; 719 720 if (!target_is_pushed (ops)) 721 push_target (ops); 722 723 update_thread_list (); 724 725 switch_to_thread (find_thread_ptid (this, ptid)); 726} 727 728void 729nto_procfs_target::post_attach (pid_t pid) 730{ 731 if (exec_bfd) 732 solib_create_inferior_hook (0); 733} 734 735static ptid_t 736do_attach (ptid_t ptid) 737{ 738 procfs_status status; 739 struct sigevent event; 740 char path[PATH_MAX]; 741 742 snprintf (path, PATH_MAX - 1, "%s%s/%d/as", 743 (nodestr != NULL) ? nodestr : "", "/proc", ptid.pid ()); 744 ctl_fd = open (path, O_RDWR); 745 if (ctl_fd == -1) 746 error (_("Couldn't open proc file %s, error %d (%s)"), path, errno, 747 safe_strerror (errno)); 748 if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK) 749 error (_("Couldn't stop process")); 750 751 /* Define a sigevent for process stopped notification. */ 752 event.sigev_notify = SIGEV_SIGNAL_THREAD; 753 event.sigev_signo = SIGUSR1; 754 event.sigev_code = 0; 755 event.sigev_value.sival_ptr = NULL; 756 event.sigev_priority = -1; 757 devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0); 758 759 if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK 760 && status.flags & _DEBUG_FLAG_STOPPED) 761 SignalKill (nto_node (), ptid.pid (), 0, SIGCONT, 0, 0); 762 nto_init_solib_absolute_prefix (); 763 return ptid_t (ptid.pid (), 0, status.tid); 764} 765 766/* Ask the user what to do when an interrupt is received. */ 767static void 768interrupt_query (void) 769{ 770 if (query (_("Interrupted while waiting for the program.\n\ 771Give up (and stop debugging it)? "))) 772 { 773 target_mourn_inferior (inferior_ptid); 774 quit (); 775 } 776} 777 778/* The user typed ^C twice. */ 779static void 780nto_handle_sigint_twice (int signo) 781{ 782 signal (signo, ofunc); 783 interrupt_query (); 784 signal (signo, nto_handle_sigint_twice); 785} 786 787static void 788nto_handle_sigint (int signo) 789{ 790 /* If this doesn't work, try more severe steps. */ 791 signal (signo, nto_handle_sigint_twice); 792 793 target_interrupt (); 794} 795 796sptid_t 797nto_procfs_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, 798 int options) 799{ 800 sigset_t set; 801 siginfo_t info; 802 procfs_status status; 803 static int exit_signo = 0; /* To track signals that cause termination. */ 804 805 ourstatus->kind = TARGET_WAITKIND_SPURIOUS; 806 807 if (inferior_ptid == null_ptid) 808 { 809 ourstatus->kind = TARGET_WAITKIND_STOPPED; 810 ourstatus->value.sig = GDB_SIGNAL_0; 811 exit_signo = 0; 812 return null_ptid; 813 } 814 815 sigemptyset (&set); 816 sigaddset (&set, SIGUSR1); 817 818 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0); 819 while (!(status.flags & _DEBUG_FLAG_ISTOP)) 820 { 821 ofunc = signal (SIGINT, nto_handle_sigint); 822 sigwaitinfo (&set, &info); 823 signal (SIGINT, ofunc); 824 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0); 825 } 826 827 nto_inferior_data (NULL)->stopped_flags = status.flags; 828 nto_inferior_data (NULL)->stopped_pc = status.ip; 829 830 if (status.flags & _DEBUG_FLAG_SSTEP) 831 { 832 ourstatus->kind = TARGET_WAITKIND_STOPPED; 833 ourstatus->value.sig = GDB_SIGNAL_TRAP; 834 } 835 /* Was it a breakpoint? */ 836 else if (status.flags & _DEBUG_FLAG_TRACE) 837 { 838 ourstatus->kind = TARGET_WAITKIND_STOPPED; 839 ourstatus->value.sig = GDB_SIGNAL_TRAP; 840 } 841 else if (status.flags & _DEBUG_FLAG_ISTOP) 842 { 843 switch (status.why) 844 { 845 case _DEBUG_WHY_SIGNALLED: 846 ourstatus->kind = TARGET_WAITKIND_STOPPED; 847 ourstatus->value.sig = 848 gdb_signal_from_host (status.info.si_signo); 849 exit_signo = 0; 850 break; 851 case _DEBUG_WHY_FAULTED: 852 ourstatus->kind = TARGET_WAITKIND_STOPPED; 853 if (status.info.si_signo == SIGTRAP) 854 { 855 ourstatus->value.sig = 0; 856 exit_signo = 0; 857 } 858 else 859 { 860 ourstatus->value.sig = 861 gdb_signal_from_host (status.info.si_signo); 862 exit_signo = ourstatus->value.sig; 863 } 864 break; 865 866 case _DEBUG_WHY_TERMINATED: 867 { 868 int waitval = 0; 869 870 waitpid (inferior_ptid.pid (), &waitval, WNOHANG); 871 if (exit_signo) 872 { 873 /* Abnormal death. */ 874 ourstatus->kind = TARGET_WAITKIND_SIGNALLED; 875 ourstatus->value.sig = exit_signo; 876 } 877 else 878 { 879 /* Normal death. */ 880 ourstatus->kind = TARGET_WAITKIND_EXITED; 881 ourstatus->value.integer = WEXITSTATUS (waitval); 882 } 883 exit_signo = 0; 884 break; 885 } 886 887 case _DEBUG_WHY_REQUESTED: 888 /* We are assuming a requested stop is due to a SIGINT. */ 889 ourstatus->kind = TARGET_WAITKIND_STOPPED; 890 ourstatus->value.sig = GDB_SIGNAL_INT; 891 exit_signo = 0; 892 break; 893 } 894 } 895 896 return ptid_t (status.pid, 0, status.tid); 897} 898 899/* Read the current values of the inferior's registers, both the 900 general register set and floating point registers (if supported) 901 and update gdb's idea of their current values. */ 902void 903nto_procfs_target::fetch_registers (struct regcache *regcache, int regno) 904{ 905 union 906 { 907 procfs_greg greg; 908 procfs_fpreg fpreg; 909 procfs_altreg altreg; 910 } 911 reg; 912 int regsize; 913 914 procfs_set_thread (regcache->ptid ()); 915 if (devctl (ctl_fd, DCMD_PROC_GETGREG, ®, sizeof (reg), ®size) == EOK) 916 nto_supply_gregset (regcache, (char *) ®.greg); 917 if (devctl (ctl_fd, DCMD_PROC_GETFPREG, ®, sizeof (reg), ®size) 918 == EOK) 919 nto_supply_fpregset (regcache, (char *) ®.fpreg); 920 if (devctl (ctl_fd, DCMD_PROC_GETALTREG, ®, sizeof (reg), ®size) 921 == EOK) 922 nto_supply_altregset (regcache, (char *) ®.altreg); 923} 924 925/* Helper for procfs_xfer_partial that handles memory transfers. 926 Arguments are like target_xfer_partial. */ 927 928static enum target_xfer_status 929procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf, 930 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len) 931{ 932 int nbytes; 933 934 if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) != (off_t) memaddr) 935 return TARGET_XFER_E_IO; 936 937 if (writebuf != NULL) 938 nbytes = write (ctl_fd, writebuf, len); 939 else 940 nbytes = read (ctl_fd, readbuf, len); 941 if (nbytes <= 0) 942 return TARGET_XFER_E_IO; 943 *xfered_len = nbytes; 944 return TARGET_XFER_OK; 945} 946 947/* Target to_xfer_partial implementation. */ 948 949enum target_xfer_status 950nto_procfs_target::xfer_partial (enum target_object object, 951 const char *annex, gdb_byte *readbuf, 952 const gdb_byte *writebuf, ULONGEST offset, 953 ULONGEST len, ULONGEST *xfered_len) 954{ 955 switch (object) 956 { 957 case TARGET_OBJECT_MEMORY: 958 return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len); 959 case TARGET_OBJECT_AUXV: 960 if (readbuf != NULL) 961 { 962 int err; 963 CORE_ADDR initial_stack; 964 debug_process_t procinfo; 965 /* For 32-bit architecture, size of auxv_t is 8 bytes. */ 966 const unsigned int sizeof_auxv_t = sizeof (auxv_t); 967 const unsigned int sizeof_tempbuf = 20 * sizeof_auxv_t; 968 int tempread; 969 gdb_byte *const tempbuf = alloca (sizeof_tempbuf); 970 971 if (tempbuf == NULL) 972 return TARGET_XFER_E_IO; 973 974 err = devctl (ctl_fd, DCMD_PROC_INFO, &procinfo, 975 sizeof procinfo, 0); 976 if (err != EOK) 977 return TARGET_XFER_E_IO; 978 979 initial_stack = procinfo.initial_stack; 980 981 /* procfs is always 'self-hosted', no byte-order manipulation. */ 982 tempread = nto_read_auxv_from_initial_stack (initial_stack, tempbuf, 983 sizeof_tempbuf, 984 sizeof (auxv_t)); 985 tempread = std::min (tempread, len) - offset; 986 memcpy (readbuf, tempbuf + offset, tempread); 987 *xfered_len = tempread; 988 return tempread ? TARGET_XFER_OK : TARGET_XFER_EOF; 989 } 990 /* Fallthru */ 991 default: 992 return this->beneath ()->xfer_partial (object, annex, 993 readbuf, writebuf, offset, len, 994 xfered_len); 995 } 996} 997 998/* Take a program previously attached to and detaches it. 999 The program resumes execution and will no longer stop 1000 on signals, etc. We'd better not have left any breakpoints 1001 in the program or it'll die when it hits one. */ 1002void 1003nto_procfs_target::detach (inferior *inf, int from_tty) 1004{ 1005 target_announce_detach (); 1006 1007 if (siggnal) 1008 SignalKill (nto_node (), inf->pid, 0, 0, 0, 0); 1009 1010 close (ctl_fd); 1011 ctl_fd = -1; 1012 1013 switch_to_no_thread (); 1014 detach_inferior (inf->pid); 1015 init_thread_list (); 1016 inf_child_maybe_unpush_target (ops); 1017} 1018 1019static int 1020procfs_breakpoint (CORE_ADDR addr, int type, int size) 1021{ 1022 procfs_break brk; 1023 1024 brk.type = type; 1025 brk.addr = addr; 1026 brk.size = size; 1027 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0); 1028 if (errno != EOK) 1029 return 1; 1030 return 0; 1031} 1032 1033int 1034nto_procfs_target::insert_breakpoint (struct gdbarch *gdbarch, 1035 struct bp_target_info *bp_tgt) 1036{ 1037 bp_tgt->placed_address = bp_tgt->reqstd_address; 1038 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0); 1039} 1040 1041int 1042nto_procfs_target::remove_breakpoint (struct gdbarch *gdbarch, 1043 struct bp_target_info *bp_tgt, 1044 enum remove_bp_reason reason) 1045{ 1046 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1); 1047} 1048 1049int 1050nto_procfs_target::insert_hw_breakpoint (struct gdbarch *gdbarch, 1051 struct bp_target_info *bp_tgt) 1052{ 1053 bp_tgt->placed_address = bp_tgt->reqstd_address; 1054 return procfs_breakpoint (bp_tgt->placed_address, 1055 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0); 1056} 1057 1058int 1059nto_procfs_target::remove_hw_breakpoint (struct gdbarch *gdbarch, 1060 struct bp_target_info *bp_tgt) 1061{ 1062 return procfs_breakpoint (bp_tgt->placed_address, 1063 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1); 1064} 1065 1066void 1067nto_procfs_target::resume (ptid_t ptid, int step, enum gdb_signal signo) 1068{ 1069 int signal_to_pass; 1070 procfs_status status; 1071 sigset_t *run_fault = (sigset_t *) (void *) &run.fault; 1072 1073 if (inferior_ptid == null_ptid) 1074 return; 1075 1076 procfs_set_thread (ptid == minus_one_ptid ? inferior_ptid : 1077 ptid); 1078 1079 run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE; 1080 if (step) 1081 run.flags |= _DEBUG_RUN_STEP; 1082 1083 sigemptyset (run_fault); 1084 sigaddset (run_fault, FLTBPT); 1085 sigaddset (run_fault, FLTTRACE); 1086 sigaddset (run_fault, FLTILL); 1087 sigaddset (run_fault, FLTPRIV); 1088 sigaddset (run_fault, FLTBOUNDS); 1089 sigaddset (run_fault, FLTIOVF); 1090 sigaddset (run_fault, FLTIZDIV); 1091 sigaddset (run_fault, FLTFPE); 1092 /* Peter V will be changing this at some point. */ 1093 sigaddset (run_fault, FLTPAGE); 1094 1095 run.flags |= _DEBUG_RUN_ARM; 1096 1097 signal_to_pass = gdb_signal_to_host (signo); 1098 1099 if (signal_to_pass) 1100 { 1101 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0); 1102 signal_to_pass = gdb_signal_to_host (signo); 1103 if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED)) 1104 { 1105 if (signal_to_pass != status.info.si_signo) 1106 { 1107 SignalKill (nto_node (), inferior_ptid.pid (), 0, 1108 signal_to_pass, 0, 0); 1109 run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG; 1110 } 1111 else /* Let it kill the program without telling us. */ 1112 sigdelset (&run.trace, signal_to_pass); 1113 } 1114 } 1115 else 1116 run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT; 1117 1118 errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0); 1119 if (errno != EOK) 1120 { 1121 perror (_("run error!\n")); 1122 return; 1123 } 1124} 1125 1126void 1127nto_procfs_target::mourn_inferior () 1128{ 1129 if (inferior_ptid != null_ptid) 1130 { 1131 SignalKill (nto_node (), inferior_ptid.pid (), 0, SIGKILL, 0, 0); 1132 close (ctl_fd); 1133 } 1134 switch_to_no_thread (); 1135 init_thread_list (); 1136 inf_child_mourn_inferior (ops); 1137} 1138 1139/* This function breaks up an argument string into an argument 1140 vector suitable for passing to execvp(). 1141 E.g., on "run a b c d" this routine would get as input 1142 the string "a b c d", and as output it would fill in argv with 1143 the four arguments "a", "b", "c", "d". The only additional 1144 functionality is simple quoting. The gdb command: 1145 run a "b c d" f 1146 will fill in argv with the three args "a", "b c d", "e". */ 1147static void 1148breakup_args (char *scratch, char **argv) 1149{ 1150 char *pp, *cp = scratch; 1151 char quoting = 0; 1152 1153 for (;;) 1154 { 1155 /* Scan past leading separators. */ 1156 quoting = 0; 1157 while (*cp == ' ' || *cp == '\t' || *cp == '\n') 1158 cp++; 1159 1160 /* Break if at end of string. */ 1161 if (*cp == '\0') 1162 break; 1163 1164 /* Take an arg. */ 1165 if (*cp == '"') 1166 { 1167 cp++; 1168 quoting = strchr (cp, '"') ? 1 : 0; 1169 } 1170 1171 *argv++ = cp; 1172 1173 /* Scan for next arg separator. */ 1174 pp = cp; 1175 if (quoting) 1176 cp = strchr (pp, '"'); 1177 if ((cp == NULL) || (!quoting)) 1178 cp = strchr (pp, ' '); 1179 if (cp == NULL) 1180 cp = strchr (pp, '\t'); 1181 if (cp == NULL) 1182 cp = strchr (pp, '\n'); 1183 1184 /* No separators => end of string => break. */ 1185 if (cp == NULL) 1186 { 1187 pp = cp; 1188 break; 1189 } 1190 1191 /* Replace the separator with a terminator. */ 1192 *cp++ = '\0'; 1193 } 1194 1195 /* Execv requires a null-terminated arg vector. */ 1196 *argv = NULL; 1197} 1198 1199void 1200nto_procfs_target::create_inferior (const char *exec_file, 1201 const std::string &allargs, 1202 char **env, int from_tty) 1203{ 1204 struct inheritance inherit; 1205 pid_t pid; 1206 int flags, errn; 1207 char **argv, *args; 1208 const char *in = "", *out = "", *err = ""; 1209 int fd, fds[3]; 1210 sigset_t set; 1211 struct inferior *inf; 1212 1213 argv = xmalloc ((allargs.size () / (unsigned) 2 + 2) * 1214 sizeof (*argv)); 1215 argv[0] = const_cast<char *> (get_exec_file (1)); 1216 if (!argv[0]) 1217 { 1218 if (exec_file) 1219 argv[0] = exec_file; 1220 else 1221 return; 1222 } 1223 1224 args = xstrdup (allargs.c_str ()); 1225 breakup_args (args, (exec_file != NULL) ? &argv[1] : &argv[0]); 1226 1227 argv = nto_parse_redirection (argv, &in, &out, &err); 1228 1229 fds[0] = STDIN_FILENO; 1230 fds[1] = STDOUT_FILENO; 1231 fds[2] = STDERR_FILENO; 1232 1233 /* If the user specified I/O via gdb's --tty= arg, use it, but only 1234 if the i/o is not also being specified via redirection. */ 1235 const char *inferior_tty = current_inferior ()->tty (); 1236 if (inferior_tty != nullptr) 1237 { 1238 if (!in[0]) 1239 in = inferior_tty; 1240 if (!out[0]) 1241 out = inferior_tty; 1242 if (!err[0]) 1243 err = inferior_tty; 1244 } 1245 1246 if (in[0]) 1247 { 1248 fd = open (in, O_RDONLY); 1249 if (fd == -1) 1250 perror (in); 1251 else 1252 fds[0] = fd; 1253 } 1254 if (out[0]) 1255 { 1256 fd = open (out, O_WRONLY); 1257 if (fd == -1) 1258 perror (out); 1259 else 1260 fds[1] = fd; 1261 } 1262 if (err[0]) 1263 { 1264 fd = open (err, O_WRONLY); 1265 if (fd == -1) 1266 perror (err); 1267 else 1268 fds[2] = fd; 1269 } 1270 1271 /* Clear any pending SIGUSR1's but keep the behavior the same. */ 1272 signal (SIGUSR1, signal (SIGUSR1, SIG_IGN)); 1273 1274 sigemptyset (&set); 1275 sigaddset (&set, SIGUSR1); 1276 sigprocmask (SIG_UNBLOCK, &set, NULL); 1277 1278 memset (&inherit, 0, sizeof (inherit)); 1279 1280 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0) 1281 { 1282 inherit.nd = nto_node (); 1283 inherit.flags |= SPAWN_SETND; 1284 inherit.flags &= ~SPAWN_EXEC; 1285 } 1286 inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD; 1287 inherit.pgroup = SPAWN_NEWPGROUP; 1288 pid = spawnp (argv[0], 3, fds, &inherit, argv, 1289 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0); 1290 xfree (args); 1291 1292 sigprocmask (SIG_BLOCK, &set, NULL); 1293 1294 if (pid == -1) 1295 error (_("Error spawning %s: %d (%s)"), argv[0], errno, 1296 safe_strerror (errno)); 1297 1298 if (fds[0] != STDIN_FILENO) 1299 close (fds[0]); 1300 if (fds[1] != STDOUT_FILENO) 1301 close (fds[1]); 1302 if (fds[2] != STDERR_FILENO) 1303 close (fds[2]); 1304 1305 ptid_t ptid = do_attach (ptid_t (pid)); 1306 update_thread_list (); 1307 switch_to_thread (find_thread_ptid (this, ptid)); 1308 1309 inf = current_inferior (); 1310 inferior_appeared (inf, pid); 1311 inf->attach_flag = 0; 1312 1313 flags = _DEBUG_FLAG_KLC; /* Kill-on-Last-Close flag. */ 1314 errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0); 1315 if (errn != EOK) 1316 { 1317 /* FIXME: expected warning? */ 1318 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n", 1319 errn, safe_strerror(errn) ); */ 1320 } 1321 if (!target_is_pushed (ops)) 1322 push_target (ops); 1323 target_terminal::init (); 1324 1325 if (exec_bfd != NULL 1326 || (symfile_objfile != NULL && symfile_objfile->obfd != NULL)) 1327 solib_create_inferior_hook (0); 1328} 1329 1330void 1331nto_procfs_target::interrupt () 1332{ 1333 devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0); 1334} 1335 1336void 1337nto_procfs_target::kill () 1338{ 1339 target_mourn_inferior (inferior_ptid); 1340} 1341 1342/* Fill buf with regset and return devctl cmd to do the setting. Return 1343 -1 if we fail to get the regset. Store size of regset in regsize. */ 1344static int 1345get_regset (int regset, char *buf, int bufsize, int *regsize) 1346{ 1347 int dev_get, dev_set; 1348 switch (regset) 1349 { 1350 case NTO_REG_GENERAL: 1351 dev_get = DCMD_PROC_GETGREG; 1352 dev_set = DCMD_PROC_SETGREG; 1353 break; 1354 1355 case NTO_REG_FLOAT: 1356 dev_get = DCMD_PROC_GETFPREG; 1357 dev_set = DCMD_PROC_SETFPREG; 1358 break; 1359 1360 case NTO_REG_ALT: 1361 dev_get = DCMD_PROC_GETALTREG; 1362 dev_set = DCMD_PROC_SETALTREG; 1363 break; 1364 1365 case NTO_REG_SYSTEM: 1366 default: 1367 return -1; 1368 } 1369 if (devctl (ctl_fd, dev_get, buf, bufsize, regsize) != EOK) 1370 return -1; 1371 1372 return dev_set; 1373} 1374 1375void 1376nto_procfs_target::store_registers (struct regcache *regcache, int regno) 1377{ 1378 union 1379 { 1380 procfs_greg greg; 1381 procfs_fpreg fpreg; 1382 procfs_altreg altreg; 1383 } 1384 reg; 1385 unsigned off; 1386 int len, regset, regsize, dev_set, err; 1387 char *data; 1388 ptid_t ptid = regcache->ptid (); 1389 1390 if (ptid == null_ptid) 1391 return; 1392 procfs_set_thread (ptid); 1393 1394 if (regno == -1) 1395 { 1396 for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++) 1397 { 1398 dev_set = get_regset (regset, (char *) ®, 1399 sizeof (reg), ®size); 1400 if (dev_set == -1) 1401 continue; 1402 1403 if (nto_regset_fill (regcache, regset, (char *) ®) == -1) 1404 continue; 1405 1406 err = devctl (ctl_fd, dev_set, ®, regsize, 0); 1407 if (err != EOK) 1408 fprintf_unfiltered (gdb_stderr, 1409 "Warning unable to write regset %d: %s\n", 1410 regno, safe_strerror (err)); 1411 } 1412 } 1413 else 1414 { 1415 regset = nto_regset_id (regno); 1416 if (regset == -1) 1417 return; 1418 1419 dev_set = get_regset (regset, (char *) ®, sizeof (reg), ®size); 1420 if (dev_set == -1) 1421 return; 1422 1423 len = nto_register_area (regcache->arch (), 1424 regno, regset, &off); 1425 1426 if (len < 1) 1427 return; 1428 1429 regcache->raw_collect (regno, (char *) ® + off); 1430 1431 err = devctl (ctl_fd, dev_set, ®, regsize, 0); 1432 if (err != EOK) 1433 fprintf_unfiltered (gdb_stderr, 1434 "Warning unable to write regset %d: %s\n", regno, 1435 safe_strerror (err)); 1436 } 1437} 1438 1439/* Set list of signals to be handled in the target. */ 1440 1441void 1442nto_procfs_target::pass_signals 1443 (gdb::array_view<const unsigned char> pass_signals) 1444{ 1445 int signo; 1446 1447 sigfillset (&run.trace); 1448 1449 for (signo = 1; signo < NSIG; signo++) 1450 { 1451 int target_signo = gdb_signal_from_host (signo); 1452 if (target_signo < pass_signals.size () && pass_signals[target_signo]) 1453 sigdelset (&run.trace, signo); 1454 } 1455} 1456 1457std::string 1458nto_procfs_target::pid_to_str (ptid_t ptid) 1459{ 1460 int pid, tid; 1461 struct tidinfo *tip; 1462 1463 pid = ptid.pid (); 1464 tid = ptid.tid (); 1465 1466#if 0 /* NYI */ 1467 tip = procfs_thread_info (pid, tid); 1468 if (tip != NULL) 1469 snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state); 1470#endif 1471 1472 return string_printf ("process %d", pid); 1473} 1474 1475/* to_can_run implementation for "target procfs". Note this really 1476 means "can this target be the default run target", which there can 1477 be only one, and we make it be "target native" like other ports. 1478 "target procfs <node>" wouldn't make sense as default run target, as 1479 it needs <node>. */ 1480 1481int 1482nto_procfs_target::can_run () 1483{ 1484 return 0; 1485} 1486 1487/* "target procfs". */ 1488static nto_procfs_target_procfs nto_procfs_ops; 1489 1490/* "target native". */ 1491static nto_procfs_target_native nto_native_ops; 1492 1493/* Create the "native" and "procfs" targets. */ 1494 1495static void 1496init_procfs_targets (void) 1497{ 1498 /* Register "target native". This is the default run target. */ 1499 add_target (nto_native_target_info, inf_child_open_target); 1500 set_native_target (&nto_native_ops); 1501 1502 /* Register "target procfs <node>". */ 1503 add_target (nto_procfs_target_info, inf_child_open_target); 1504} 1505 1506#define OSTYPE_NTO 1 1507 1508void _initialize_procfs (); 1509void 1510_initialize_procfs () 1511{ 1512 sigset_t set; 1513 1514 init_procfs_targets (); 1515 1516 /* We use SIGUSR1 to gain control after we block waiting for a process. 1517 We use sigwaitevent to wait. */ 1518 sigemptyset (&set); 1519 sigaddset (&set, SIGUSR1); 1520 sigprocmask (SIG_BLOCK, &set, NULL); 1521 1522 /* Initially, make sure all signals are reported. */ 1523 sigfillset (&run.trace); 1524 1525 /* Stuff some information. */ 1526 nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags; 1527 nto_cpuinfo_valid = 1; 1528 1529 add_info ("pidlist", procfs_pidlist, _("pidlist")); 1530 add_info ("meminfo", procfs_meminfo, _("memory information")); 1531 1532 nto_is_nto_target = procfs_is_nto_target; 1533} 1534 1535 1536static int 1537procfs_hw_watchpoint (int addr, int len, enum target_hw_bp_type type) 1538{ 1539 procfs_break brk; 1540 1541 switch (type) 1542 { 1543 case hw_read: 1544 brk.type = _DEBUG_BREAK_RD; 1545 break; 1546 case hw_access: 1547 brk.type = _DEBUG_BREAK_RW; 1548 break; 1549 default: /* Modify. */ 1550/* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */ 1551 brk.type = _DEBUG_BREAK_RW; 1552 } 1553 brk.type |= _DEBUG_BREAK_HW; /* Always ask for HW. */ 1554 brk.addr = addr; 1555 brk.size = len; 1556 1557 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0); 1558 if (errno != EOK) 1559 { 1560 perror (_("Failed to set hardware watchpoint")); 1561 return -1; 1562 } 1563 return 0; 1564} 1565 1566bool 1567nto_procfs_target::can_use_hw_breakpoint (enum bptype type, 1568 int cnt, int othertype) 1569{ 1570 return 1; 1571} 1572 1573int 1574nto_procfs_target::remove_hw_watchpoint (CORE_ADDR addr, int len, 1575 enum target_hw_bp_type type, 1576 struct expression *cond) 1577{ 1578 return procfs_hw_watchpoint (addr, -1, type); 1579} 1580 1581int 1582nto_procfs_target::insert_hw_watchpoint (CORE_ADDR addr, int len, 1583 enum target_hw_bp_type type, 1584 struct expression *cond) 1585{ 1586 return procfs_hw_watchpoint (addr, len, type); 1587} 1588 1589bool 1590nto_procfs_target::stopped_by_watchpoint () 1591{ 1592 /* NOTE: nto_stopped_by_watchpoint will be called ONLY while we are 1593 stopped due to a SIGTRAP. This assumes gdb works in 'all-stop' mode; 1594 future gdb versions will likely run in 'non-stop' mode in which case 1595 we will have to store/examine statuses per thread in question. 1596 Until then, this will work fine. */ 1597 1598 struct inferior *inf = current_inferior (); 1599 struct nto_inferior_data *inf_data; 1600 1601 gdb_assert (inf != NULL); 1602 1603 inf_data = nto_inferior_data (inf); 1604 1605 return inf_data->stopped_flags 1606 & (_DEBUG_FLAG_TRACE_RD 1607 | _DEBUG_FLAG_TRACE_WR 1608 | _DEBUG_FLAG_TRACE_MODIFY); 1609} 1610