gdb/corelow.c

   1 /* Core dump and executable file functions below target vector, for GDB.
   2
   3    Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "arch-utils.h"
  24 #include "gdb_string.h"
  25 #include <errno.h>
  26 #include <signal.h>
  27 #include <fcntl.h>
  28 #ifdef HAVE_SYS_FILE_H
  29 #include <sys/file.h>           /* needed for F_OK and friends */
  30 #endif
  31 #include "frame.h"              /* required by inferior.h */
  32 #include "inferior.h"
  33 #include "symtab.h"
  34 #include "command.h"
  35 #include "bfd.h"
  36 #include "target.h"
  37 #include "gdbcore.h"
  38 #include "gdbthread.h"
  39 #include "regcache.h"
  40 #include "regset.h"
  41 #include "symfile.h"
  42 #include "exec.h"
  43 #include "readline/readline.h"
  44 #include "gdb_assert.h"
  45 #include "exceptions.h"
  46 #include "solib.h"
  47 #include "filenames.h"
  48
  49
  50 #ifndef O_LARGEFILE
  51 #define O_LARGEFILE 0
  52 #endif
  53
  54 /* List of all available core_fns.  On gdb startup, each core file
  55    register reader calls deprecated_add_core_fns() to register
  56    information on each core format it is prepared to read.  */
  57
  58 static struct core_fns *core_file_fns = NULL;
  59
  60 /* The core_fns for a core file handler that is prepared to read the core
  61    file currently open on core_bfd. */
  62
  63 static struct core_fns *core_vec = NULL;
  64
  65 /* FIXME: kettenis/20031023: Eventually this variable should
  66    disappear.  */
  67
  68 struct gdbarch *core_gdbarch = NULL;
  69
  70 static void core_files_info (struct target_ops *);
  71
  72 static struct core_fns *sniff_core_bfd (bfd *);
  73
  74 static int gdb_check_format (bfd *);
  75
  76 static void core_open (char *, int);
  77
  78 static void core_detach (char *, int);
  79
  80 static void core_close (int);
  81
  82 static void core_close_cleanup (void *ignore);
  83
  84 static void get_core_registers (struct regcache *, int);
  85
  86 static void add_to_thread_list (bfd *, asection *, void *);
  87
  88 static int core_file_thread_alive (ptid_t tid);
  89
  90 static void init_core_ops (void);
  91
  92 void _initialize_corelow (void);
  93
  94 struct target_ops core_ops;
  95
  96 /* Link a new core_fns into the global core_file_fns list.  Called on gdb
  97    startup by the _initialize routine in each core file register reader, to
  98    register information about each format the the reader is prepared to
  99    handle. */
 100
 101 void
 102 deprecated_add_core_fns (struct core_fns *cf)
 103 {
 104   cf->next = core_file_fns;
 105   core_file_fns = cf;
 106 }
 107
 108 /* The default function that core file handlers can use to examine a
 109    core file BFD and decide whether or not to accept the job of
 110    reading the core file. */
 111
 112 int
 113 default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
 114 {
 115   int result;
 116
 117   result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
 118   return (result);
 119 }
 120
 121 /* Walk through the list of core functions to find a set that can
 122    handle the core file open on ABFD.  Default to the first one in the
 123    list if nothing matches.  Returns pointer to set that is
 124    selected. */
 125
 126 static struct core_fns *
 127 sniff_core_bfd (bfd *abfd)
 128 {
 129   struct core_fns *cf;
 130   struct core_fns *yummy = NULL;
 131   int matches = 0;;
 132
 133   /* Don't sniff if we have support for register sets in CORE_GDBARCH.  */
 134   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 135     return NULL;
 136
 137   for (cf = core_file_fns; cf != NULL; cf = cf->next)
 138     {
 139       if (cf->core_sniffer (cf, abfd))
 140         {
 141           yummy = cf;
 142           matches++;
 143         }
 144     }
 145   if (matches > 1)
 146     {
 147       warning (_("\"%s\": ambiguous core format, %d handlers match"),
 148                bfd_get_filename (abfd), matches);
 149     }
 150   else if (matches == 0)
 151     {
 152       warning (_("\"%s\": no core file handler recognizes format, using default"),
 153                bfd_get_filename (abfd));
 154     }
 155   if (yummy == NULL)
 156     {
 157       yummy = core_file_fns;
 158     }
 159   return (yummy);
 160 }
 161
 162 /* The default is to reject every core file format we see.  Either
 163    BFD has to recognize it, or we have to provide a function in the
 164    core file handler that recognizes it. */
 165
 166 int
 167 default_check_format (bfd *abfd)
 168 {
 169   return (0);
 170 }
 171
 172 /* Attempt to recognize core file formats that BFD rejects. */
 173
 174 static int
 175 gdb_check_format (bfd *abfd)
 176 {
 177   struct core_fns *cf;
 178
 179   for (cf = core_file_fns; cf != NULL; cf = cf->next)
 180     {
 181       if (cf->check_format (abfd))
 182         {
 183           return (1);
 184         }
 185     }
 186   return (0);
 187 }
 188
 189 /* Discard all vestiges of any previous core file and mark data and stack
 190    spaces as empty.  */
 191
 192 static void
 193 core_close (int quitting)
 194 {
 195   char *name;
 196
 197   if (core_bfd)
 198     {
 199       inferior_ptid = null_ptid;        /* Avoid confusion from thread stuff */
 200
 201       /* Clear out solib state while the bfd is still open. See
 202          comments in clear_solib in solib.c. */
 203       clear_solib ();
 204
 205       name = bfd_get_filename (core_bfd);
 206       if (!bfd_close (core_bfd))
 207         warning (_("cannot close \"%s\": %s"),
 208                  name, bfd_errmsg (bfd_get_error ()));
 209       xfree (name);
 210       core_bfd = NULL;
 211       if (core_ops.to_sections)
 212         {
 213           xfree (core_ops.to_sections);
 214           core_ops.to_sections = NULL;
 215           core_ops.to_sections_end = NULL;
 216         }
 217     }
 218   core_vec = NULL;
 219   core_gdbarch = NULL;
 220 }
 221
 222 static void
 223 core_close_cleanup (void *ignore)
 224 {
 225   core_close (0/*ignored*/);
 226 }
 227
 228 /* Look for sections whose names start with `.reg/' so that we can extract the
 229    list of threads in a core file.  */
 230
 231 static void
 232 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
 233 {
 234   int thread_id;
 235   asection *reg_sect = (asection *) reg_sect_arg;
 236
 237   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
 238     return;
 239
 240   thread_id = atoi (bfd_section_name (abfd, asect) + 5);
 241
 242   add_thread (pid_to_ptid (thread_id));
 243
 244 /* Warning, Will Robinson, looking at BFD private data! */
 245
 246   if (reg_sect != NULL
 247       && asect->filepos == reg_sect->filepos)   /* Did we find .reg? */
 248     inferior_ptid = pid_to_ptid (thread_id);    /* Yes, make it current */
 249 }
 250
 251 /* This routine opens and sets up the core file bfd.  */
 252
 253 static void
 254 core_open (char *filename, int from_tty)
 255 {
 256   const char *p;
 257   int siggy;
 258   struct cleanup *old_chain;
 259   char *temp;
 260   bfd *temp_bfd;
 261   int scratch_chan;
 262   int flags;
 263
 264   target_preopen (from_tty);
 265   if (!filename)
 266     {
 267       if (core_bfd)
 268         error (_("No core file specified.  (Use `detach' to stop debugging a core file.)"));
 269       else
 270         error (_("No core file specified."));
 271     }
 272
 273   filename = tilde_expand (filename);
 274   if (!IS_ABSOLUTE_PATH(filename))
 275     {
 276       temp = concat (current_directory, "/", filename, (char *)NULL);
 277       xfree (filename);
 278       filename = temp;
 279     }
 280
 281   old_chain = make_cleanup (xfree, filename);
 282
 283   flags = O_BINARY | O_LARGEFILE;
 284   if (write_files)
 285     flags |= O_RDWR;
 286   else
 287     flags |= O_RDONLY;
 288   scratch_chan = open (filename, flags, 0);
 289   if (scratch_chan < 0)
 290     perror_with_name (filename);
 291
 292   temp_bfd = bfd_fopen (filename, gnutarget,
 293                         write_files ? FOPEN_RUB : FOPEN_RB,
 294                         scratch_chan);
 295   if (temp_bfd == NULL)
 296     perror_with_name (filename);
 297
 298   if (!bfd_check_format (temp_bfd, bfd_core) &&
 299       !gdb_check_format (temp_bfd))
 300     {
 301       /* Do it after the err msg */
 302       /* FIXME: should be checking for errors from bfd_close (for one thing,
 303          on error it does not free all the storage associated with the
 304          bfd).  */
 305       make_cleanup_bfd_close (temp_bfd);
 306       error (_("\"%s\" is not a core dump: %s"),
 307              filename, bfd_errmsg (bfd_get_error ()));
 308     }
 309
 310   /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
 311
 312   discard_cleanups (old_chain); /* Don't free filename any more */
 313   unpush_target (&core_ops);
 314   core_bfd = temp_bfd;
 315   old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
 316
 317   /* FIXME: kettenis/20031023: This is very dangerous.  The
 318      CORE_GDBARCH that results from this call may very well be
 319      different from CURRENT_GDBARCH.  However, its methods may only
 320      work if it is selected as the current architecture, because they
 321      rely on swapped data (see gdbarch.c).  We should get rid of that
 322      swapped data.  */
 323   core_gdbarch = gdbarch_from_bfd (core_bfd);
 324
 325   /* Find a suitable core file handler to munch on core_bfd */
 326   core_vec = sniff_core_bfd (core_bfd);
 327
 328   validate_files ();
 329
 330   /* Find the data section */
 331   if (build_section_table (core_bfd, &core_ops.to_sections,
 332                            &core_ops.to_sections_end))
 333     error (_("\"%s\": Can't find sections: %s"),
 334            bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
 335
 336   /* If we have no exec file, try to set the architecture from the
 337      core file.  We don't do this unconditionally since an exec file
 338      typically contains more information that helps us determine the
 339      architecture than a core file.  */
 340   if (!exec_bfd)
 341     set_gdbarch_from_file (core_bfd);
 342
 343   push_target (&core_ops);
 344   discard_cleanups (old_chain);
 345
 346   /* This is done first, before anything has a chance to query the
 347      inferior for information such as symbols.  */
 348   post_create_inferior (&core_ops, from_tty);
 349
 350   p = bfd_core_file_failing_command (core_bfd);
 351   if (p)
 352     printf_filtered (_("Core was generated by `%s'.\n"), p);
 353
 354   siggy = bfd_core_file_failing_signal (core_bfd);
 355   if (siggy > 0)
 356     /* NOTE: target_signal_from_host() converts a target signal value
 357        into gdb's internal signal value.  Unfortunately gdb's internal
 358        value is called ``target_signal'' and this function got the
 359        name ..._from_host(). */
 360     printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy,
 361                      target_signal_to_string (
 362                        gdbarch_target_signal_from_host (core_gdbarch, siggy)));
 363
 364   /* Build up thread list from BFD sections. */
 365
 366   init_thread_list ();
 367   bfd_map_over_sections (core_bfd, add_to_thread_list,
 368                          bfd_get_section_by_name (core_bfd, ".reg"));
 369
 370   /* Fetch all registers from core file.  */
 371   target_fetch_registers (get_current_regcache (), -1);
 372
 373   /* Now, set up the frame cache, and print the top of stack.  */
 374   reinit_frame_cache ();
 375   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 376 }
 377
 378 static void
 379 core_detach (char *args, int from_tty)
 380 {
 381   if (args)
 382     error (_("Too many arguments"));
 383   unpush_target (&core_ops);
 384   reinit_frame_cache ();
 385   if (from_tty)
 386     printf_filtered (_("No core file now.\n"));
 387 }
 388
 389
 390 /* Try to retrieve registers from a section in core_bfd, and supply
 391    them to core_vec->core_read_registers, as the register set numbered
 392    WHICH.
 393
 394    If inferior_ptid is zero, do the single-threaded thing: look for a
 395    section named NAME.  If inferior_ptid is non-zero, do the
 396    multi-threaded thing: look for a section named "NAME/PID", where
 397    PID is the shortest ASCII decimal representation of inferior_ptid.
 398
 399    HUMAN_NAME is a human-readable name for the kind of registers the
 400    NAME section contains, for use in error messages.
 401
 402    If REQUIRED is non-zero, print an error if the core file doesn't
 403    have a section by the appropriate name.  Otherwise, just do nothing.  */
 404
 405 static void
 406 get_core_register_section (struct regcache *regcache,
 407                            char *name,
 408                            int which,
 409                            char *human_name,
 410                            int required)
 411 {
 412   static char *section_name = NULL;
 413   struct bfd_section *section;
 414   bfd_size_type size;
 415   char *contents;
 416
 417   xfree (section_name);
 418   if (PIDGET (inferior_ptid))
 419     section_name = xstrprintf ("%s/%d", name, PIDGET (inferior_ptid));
 420   else
 421     section_name = xstrdup (name);
 422
 423   section = bfd_get_section_by_name (core_bfd, section_name);
 424   if (! section)
 425     {
 426       if (required)
 427         warning (_("Couldn't find %s registers in core file."), human_name);
 428       return;
 429     }
 430
 431   size = bfd_section_size (core_bfd, section);
 432   contents = alloca (size);
 433   if (! bfd_get_section_contents (core_bfd, section, contents,
 434                                   (file_ptr) 0, size))
 435     {
 436       warning (_("Couldn't read %s registers from `%s' section in core file."),
 437                human_name, name);
 438       return;
 439     }
 440
 441   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 442     {
 443       const struct regset *regset;
 444
 445       regset = gdbarch_regset_from_core_section (core_gdbarch, name, size);
 446       if (regset == NULL)
 447         {
 448           if (required)
 449             warning (_("Couldn't recognize %s registers in core file."),
 450                      human_name);
 451           return;
 452         }
 453
 454       regset->supply_regset (regset, regcache, -1, contents, size);
 455       return;
 456     }
 457
 458   gdb_assert (core_vec);
 459   core_vec->core_read_registers (regcache, contents, size, which,
 460                                  ((CORE_ADDR)
 461                                   bfd_section_vma (core_bfd, section)));
 462 }
 463
 464
 465 /* Get the registers out of a core file.  This is the machine-
 466    independent part.  Fetch_core_registers is the machine-dependent
 467    part, typically implemented in the xm-file for each architecture.  */
 468
 469 /* We just get all the registers, so we don't use regno.  */
 470
 471 static void
 472 get_core_registers (struct regcache *regcache, int regno)
 473 {
 474   int i;
 475
 476   if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 477       && (core_vec == NULL || core_vec->core_read_registers == NULL))
 478     {
 479       fprintf_filtered (gdb_stderr,
 480                      "Can't fetch registers from this type of core file\n");
 481       return;
 482     }
 483
 484   get_core_register_section (regcache,
 485                              ".reg", 0, "general-purpose", 1);
 486   get_core_register_section (regcache,
 487                              ".reg2", 2, "floating-point", 0);
 488   get_core_register_section (regcache,
 489                              ".reg-xfp", 3, "extended floating-point", 0);
 490   get_core_register_section (regcache,
 491                              ".reg-ppc-vmx", 3, "ppc Altivec", 0);
 492   get_core_register_section (regcache,
 493                              ".reg-ppc-vsx", 4, "POWER7 VSX", 0);
 494
 495   /* Supply dummy value for all registers not found in the core.  */
 496   for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 497     if (!regcache_valid_p (regcache, i))
 498       regcache_raw_supply (regcache, i, NULL);
 499 }
 500
 501 static void
 502 core_files_info (struct target_ops *t)
 503 {
 504   print_section_info (t, core_bfd);
 505 }
 506 \f
 507 static LONGEST
 508 core_xfer_partial (struct target_ops *ops, enum target_object object,
 509                    const char *annex, gdb_byte *readbuf,
 510                    const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
 511 {
 512   switch (object)
 513     {
 514     case TARGET_OBJECT_MEMORY:
 515       if (readbuf)
 516         return (*ops->deprecated_xfer_memory) (offset, readbuf,
 517                                                len, 0/*read*/, NULL, ops);
 518       if (writebuf)
 519         return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
 520                                                len, 1/*write*/, NULL, ops);
 521       return -1;
 522
 523     case TARGET_OBJECT_AUXV:
 524       if (readbuf)
 525         {
 526           /* When the aux vector is stored in core file, BFD
 527              represents this with a fake section called ".auxv".  */
 528
 529           struct bfd_section *section;
 530           bfd_size_type size;
 531           char *contents;
 532
 533           section = bfd_get_section_by_name (core_bfd, ".auxv");
 534           if (section == NULL)
 535             return -1;
 536
 537           size = bfd_section_size (core_bfd, section);
 538           if (offset >= size)
 539             return 0;
 540           size -= offset;
 541           if (size > len)
 542             size = len;
 543           if (size > 0
 544               && !bfd_get_section_contents (core_bfd, section, readbuf,
 545                                             (file_ptr) offset, size))
 546             {
 547               warning (_("Couldn't read NT_AUXV note in core file."));
 548               return -1;
 549             }
 550
 551           return size;
 552         }
 553       return -1;
 554
 555     case TARGET_OBJECT_WCOOKIE:
 556       if (readbuf)
 557         {
 558           /* When the StackGhost cookie is stored in core file, BFD
 559              represents this with a fake section called ".wcookie".  */
 560
 561           struct bfd_section *section;
 562           bfd_size_type size;
 563           char *contents;
 564
 565           section = bfd_get_section_by_name (core_bfd, ".wcookie");
 566           if (section == NULL)
 567             return -1;
 568
 569           size = bfd_section_size (core_bfd, section);
 570           if (offset >= size)
 571             return 0;
 572           size -= offset;
 573           if (size > len)
 574             size = len;
 575           if (size > 0
 576               && !bfd_get_section_contents (core_bfd, section, readbuf,
 577                                             (file_ptr) offset, size))
 578             {
 579               warning (_("Couldn't read StackGhost cookie in core file."));
 580               return -1;
 581             }
 582
 583           return size;
 584         }
 585       return -1;
 586
 587     case TARGET_OBJECT_LIBRARIES:
 588       if (core_gdbarch
 589           && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
 590         {
 591           if (writebuf)
 592             return -1;
 593           return
 594             gdbarch_core_xfer_shared_libraries (core_gdbarch,
 595                                                 readbuf, offset, len);
 596         }
 597       /* FALL THROUGH */
 598
 599     default:
 600       if (ops->beneath != NULL)
 601         return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
 602                                               readbuf, writebuf, offset, len);
 603       return -1;
 604     }
 605 }
 606
 607 \f
 608 /* If mourn is being called in all the right places, this could be say
 609    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 610
 611 static int
 612 ignore (struct bp_target_info *bp_tgt)
 613 {
 614   return 0;
 615 }
 616
 617
 618 /* Okay, let's be honest: threads gleaned from a core file aren't
 619    exactly lively, are they?  On the other hand, if we don't claim
 620    that each & every one is alive, then we don't get any of them
 621    to appear in an "info thread" command, which is quite a useful
 622    behaviour.
 623  */
 624 static int
 625 core_file_thread_alive (ptid_t tid)
 626 {
 627   return 1;
 628 }
 629
 630 /* Ask the current architecture what it knows about this core file.
 631    That will be used, in turn, to pick a better architecture.  This
 632    wrapper could be avoided if targets got a chance to specialize
 633    core_ops.  */
 634
 635 static const struct target_desc *
 636 core_read_description (struct target_ops *target)
 637 {
 638   if (gdbarch_core_read_description_p (current_gdbarch))
 639     return gdbarch_core_read_description (current_gdbarch, target, core_bfd);
 640
 641   return NULL;
 642 }
 643
 644 /* Fill in core_ops with its defined operations and properties.  */
 645
 646 static void
 647 init_core_ops (void)
 648 {
 649   core_ops.to_shortname = "core";
 650   core_ops.to_longname = "Local core dump file";
 651   core_ops.to_doc =
 652     "Use a core file as a target.  Specify the filename of the core file.";
 653   core_ops.to_open = core_open;
 654   core_ops.to_close = core_close;
 655   core_ops.to_attach = find_default_attach;
 656   core_ops.to_detach = core_detach;
 657   core_ops.to_fetch_registers = get_core_registers;
 658   core_ops.to_xfer_partial = core_xfer_partial;
 659   core_ops.deprecated_xfer_memory = xfer_memory;
 660   core_ops.to_files_info = core_files_info;
 661   core_ops.to_insert_breakpoint = ignore;
 662   core_ops.to_remove_breakpoint = ignore;
 663   core_ops.to_create_inferior = find_default_create_inferior;
 664   core_ops.to_thread_alive = core_file_thread_alive;
 665   core_ops.to_read_description = core_read_description;
 666   core_ops.to_stratum = core_stratum;
 667   core_ops.to_has_memory = 1;
 668   core_ops.to_has_stack = 1;
 669   core_ops.to_has_registers = 1;
 670   core_ops.to_magic = OPS_MAGIC;
 671 }
 672
 673 /* non-zero if we should not do the add_target call in
 674    _initialize_corelow; not initialized (i.e., bss) so that
 675    the target can initialize it (i.e., data) if appropriate.
 676    This needs to be set at compile time because we don't know
 677    for sure whether the target's initialize routine is called
 678    before us or after us. */
 679 int coreops_suppress_target;
 680
 681 void
 682 _initialize_corelow (void)
 683 {
 684   init_core_ops ();
 685
 686   if (!coreops_suppress_target)
 687     add_target (&core_ops);
 688 }