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 ontop;
 262   int scratch_chan;
 263   int flags;
 264
 265   target_preopen (from_tty);
 266   if (!filename)
 267     {
 268       if (core_bfd)
 269         error (_("No core file specified.  (Use `detach' to stop debugging a core file.)"));
 270       else
 271         error (_("No core file specified."));
 272     }
 273
 274   filename = tilde_expand (filename);
 275   if (!IS_ABSOLUTE_PATH(filename))
 276     {
 277       temp = concat (current_directory, "/", filename, (char *)NULL);
 278       xfree (filename);
 279       filename = temp;
 280     }
 281
 282   old_chain = make_cleanup (xfree, filename);
 283
 284   flags = O_BINARY | O_LARGEFILE;
 285   if (write_files)
 286     flags |= O_RDWR;
 287   else
 288     flags |= O_RDONLY;
 289   scratch_chan = open (filename, flags, 0);
 290   if (scratch_chan < 0)
 291     perror_with_name (filename);
 292
 293   temp_bfd = bfd_fopen (filename, gnutarget,
 294                         write_files ? FOPEN_RUB : FOPEN_RB,
 295                         scratch_chan);
 296   if (temp_bfd == NULL)
 297     perror_with_name (filename);
 298
 299   if (!bfd_check_format (temp_bfd, bfd_core) &&
 300       !gdb_check_format (temp_bfd))
 301     {
 302       /* Do it after the err msg */
 303       /* FIXME: should be checking for errors from bfd_close (for one thing,
 304          on error it does not free all the storage associated with the
 305          bfd).  */
 306       make_cleanup_bfd_close (temp_bfd);
 307       error (_("\"%s\" is not a core dump: %s"),
 308              filename, bfd_errmsg (bfd_get_error ()));
 309     }
 310
 311   /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
 312
 313   discard_cleanups (old_chain); /* Don't free filename any more */
 314   unpush_target (&core_ops);
 315   core_bfd = temp_bfd;
 316   old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
 317
 318   /* FIXME: kettenis/20031023: This is very dangerous.  The
 319      CORE_GDBARCH that results from this call may very well be
 320      different from CURRENT_GDBARCH.  However, its methods may only
 321      work if it is selected as the current architecture, because they
 322      rely on swapped data (see gdbarch.c).  We should get rid of that
 323      swapped data.  */
 324   core_gdbarch = gdbarch_from_bfd (core_bfd);
 325
 326   /* Find a suitable core file handler to munch on core_bfd */
 327   core_vec = sniff_core_bfd (core_bfd);
 328
 329   validate_files ();
 330
 331   /* Find the data section */
 332   if (build_section_table (core_bfd, &core_ops.to_sections,
 333                            &core_ops.to_sections_end))
 334     error (_("\"%s\": Can't find sections: %s"),
 335            bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
 336
 337   /* If we have no exec file, try to set the architecture from the
 338      core file.  We don't do this unconditionally since an exec file
 339      typically contains more information that helps us determine the
 340      architecture than a core file.  */
 341   if (!exec_bfd)
 342     set_gdbarch_from_file (core_bfd);
 343
 344   ontop = !push_target (&core_ops);
 345   discard_cleanups (old_chain);
 346
 347   /* This is done first, before anything has a chance to query the
 348      inferior for information such as symbols.  */
 349   post_create_inferior (&core_ops, from_tty);
 350
 351   p = bfd_core_file_failing_command (core_bfd);
 352   if (p)
 353     printf_filtered (_("Core was generated by `%s'.\n"), p);
 354
 355   siggy = bfd_core_file_failing_signal (core_bfd);
 356   if (siggy > 0)
 357     /* NOTE: target_signal_from_host() converts a target signal value
 358        into gdb's internal signal value.  Unfortunately gdb's internal
 359        value is called ``target_signal'' and this function got the
 360        name ..._from_host(). */
 361     printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy,
 362                      target_signal_to_string (
 363                        gdbarch_target_signal_from_host (core_gdbarch, siggy)));
 364
 365   /* Build up thread list from BFD sections. */
 366
 367   init_thread_list ();
 368   bfd_map_over_sections (core_bfd, add_to_thread_list,
 369                          bfd_get_section_by_name (core_bfd, ".reg"));
 370
 371   if (ontop)
 372     {
 373       /* Fetch all registers from core file.  */
 374       target_fetch_registers (get_current_regcache (), -1);
 375
 376       /* Now, set up the frame cache, and print the top of stack.  */
 377       reinit_frame_cache ();
 378       print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 379     }
 380   else
 381     {
 382       warning (
 383                 "you won't be able to access this core file until you terminate\n\
 384 your %s; do ``info files''", target_longname);
 385     }
 386 }
 387
 388 static void
 389 core_detach (char *args, int from_tty)
 390 {
 391   if (args)
 392     error (_("Too many arguments"));
 393   unpush_target (&core_ops);
 394   reinit_frame_cache ();
 395   if (from_tty)
 396     printf_filtered (_("No core file now.\n"));
 397 }
 398
 399
 400 /* Try to retrieve registers from a section in core_bfd, and supply
 401    them to core_vec->core_read_registers, as the register set numbered
 402    WHICH.
 403
 404    If inferior_ptid is zero, do the single-threaded thing: look for a
 405    section named NAME.  If inferior_ptid is non-zero, do the
 406    multi-threaded thing: look for a section named "NAME/PID", where
 407    PID is the shortest ASCII decimal representation of inferior_ptid.
 408
 409    HUMAN_NAME is a human-readable name for the kind of registers the
 410    NAME section contains, for use in error messages.
 411
 412    If REQUIRED is non-zero, print an error if the core file doesn't
 413    have a section by the appropriate name.  Otherwise, just do nothing.  */
 414
 415 static void
 416 get_core_register_section (struct regcache *regcache,
 417                            char *name,
 418                            int which,
 419                            char *human_name,
 420                            int required)
 421 {
 422   static char *section_name = NULL;
 423   struct bfd_section *section;
 424   bfd_size_type size;
 425   char *contents;
 426
 427   xfree (section_name);
 428   if (PIDGET (inferior_ptid))
 429     section_name = xstrprintf ("%s/%d", name, PIDGET (inferior_ptid));
 430   else
 431     section_name = xstrdup (name);
 432
 433   section = bfd_get_section_by_name (core_bfd, section_name);
 434   if (! section)
 435     {
 436       if (required)
 437         warning (_("Couldn't find %s registers in core file."), human_name);
 438       return;
 439     }
 440
 441   size = bfd_section_size (core_bfd, section);
 442   contents = alloca (size);
 443   if (! bfd_get_section_contents (core_bfd, section, contents,
 444                                   (file_ptr) 0, size))
 445     {
 446       warning (_("Couldn't read %s registers from `%s' section in core file."),
 447                human_name, name);
 448       return;
 449     }
 450
 451   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 452     {
 453       const struct regset *regset;
 454
 455       regset = gdbarch_regset_from_core_section (core_gdbarch, name, size);
 456       if (regset == NULL)
 457         {
 458           if (required)
 459             warning (_("Couldn't recognize %s registers in core file."),
 460                      human_name);
 461           return;
 462         }
 463
 464       regset->supply_regset (regset, regcache, -1, contents, size);
 465       return;
 466     }
 467
 468   gdb_assert (core_vec);
 469   core_vec->core_read_registers (regcache, contents, size, which,
 470                                  ((CORE_ADDR)
 471                                   bfd_section_vma (core_bfd, section)));
 472 }
 473
 474
 475 /* Get the registers out of a core file.  This is the machine-
 476    independent part.  Fetch_core_registers is the machine-dependent
 477    part, typically implemented in the xm-file for each architecture.  */
 478
 479 /* We just get all the registers, so we don't use regno.  */
 480
 481 static void
 482 get_core_registers (struct regcache *regcache, int regno)
 483 {
 484   int i;
 485
 486   if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 487       && (core_vec == NULL || core_vec->core_read_registers == NULL))
 488     {
 489       fprintf_filtered (gdb_stderr,
 490                      "Can't fetch registers from this type of core file\n");
 491       return;
 492     }
 493
 494   get_core_register_section (regcache,
 495                              ".reg", 0, "general-purpose", 1);
 496   get_core_register_section (regcache,
 497                              ".reg2", 2, "floating-point", 0);
 498   get_core_register_section (regcache,
 499                              ".reg-xfp", 3, "extended floating-point", 0);
 500   get_core_register_section (regcache,
 501                              ".reg-ppc-vmx", 3, "ppc Altivec", 0);
 502   get_core_register_section (regcache,
 503                              ".reg-ppc-vsx", 4, "POWER7 VSX", 0);
 504
 505   /* Supply dummy value for all registers not found in the core.  */
 506   for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 507     if (!regcache_valid_p (regcache, i))
 508       regcache_raw_supply (regcache, i, NULL);
 509 }
 510
 511 static void
 512 core_files_info (struct target_ops *t)
 513 {
 514   print_section_info (t, core_bfd);
 515 }
 516 \f
 517 static LONGEST
 518 core_xfer_partial (struct target_ops *ops, enum target_object object,
 519                    const char *annex, gdb_byte *readbuf,
 520                    const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
 521 {
 522   switch (object)
 523     {
 524     case TARGET_OBJECT_MEMORY:
 525       if (readbuf)
 526         return (*ops->deprecated_xfer_memory) (offset, readbuf,
 527                                                len, 0/*read*/, NULL, ops);
 528       if (writebuf)
 529         return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
 530                                                len, 1/*write*/, NULL, ops);
 531       return -1;
 532
 533     case TARGET_OBJECT_AUXV:
 534       if (readbuf)
 535         {
 536           /* When the aux vector is stored in core file, BFD
 537              represents this with a fake section called ".auxv".  */
 538
 539           struct bfd_section *section;
 540           bfd_size_type size;
 541           char *contents;
 542
 543           section = bfd_get_section_by_name (core_bfd, ".auxv");
 544           if (section == NULL)
 545             return -1;
 546
 547           size = bfd_section_size (core_bfd, section);
 548           if (offset >= size)
 549             return 0;
 550           size -= offset;
 551           if (size > len)
 552             size = len;
 553           if (size > 0
 554               && !bfd_get_section_contents (core_bfd, section, readbuf,
 555                                             (file_ptr) offset, size))
 556             {
 557               warning (_("Couldn't read NT_AUXV note in core file."));
 558               return -1;
 559             }
 560
 561           return size;
 562         }
 563       return -1;
 564
 565     case TARGET_OBJECT_WCOOKIE:
 566       if (readbuf)
 567         {
 568           /* When the StackGhost cookie is stored in core file, BFD
 569              represents this with a fake section called ".wcookie".  */
 570
 571           struct bfd_section *section;
 572           bfd_size_type size;
 573           char *contents;
 574
 575           section = bfd_get_section_by_name (core_bfd, ".wcookie");
 576           if (section == NULL)
 577             return -1;
 578
 579           size = bfd_section_size (core_bfd, section);
 580           if (offset >= size)
 581             return 0;
 582           size -= offset;
 583           if (size > len)
 584             size = len;
 585           if (size > 0
 586               && !bfd_get_section_contents (core_bfd, section, readbuf,
 587                                             (file_ptr) offset, size))
 588             {
 589               warning (_("Couldn't read StackGhost cookie in core file."));
 590               return -1;
 591             }
 592
 593           return size;
 594         }
 595       return -1;
 596
 597     case TARGET_OBJECT_LIBRARIES:
 598       if (core_gdbarch
 599           && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
 600         {
 601           if (writebuf)
 602             return -1;
 603           return
 604             gdbarch_core_xfer_shared_libraries (core_gdbarch,
 605                                                 readbuf, offset, len);
 606         }
 607       /* FALL THROUGH */
 608
 609     default:
 610       if (ops->beneath != NULL)
 611         return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
 612                                               readbuf, writebuf, offset, len);
 613       return -1;
 614     }
 615 }
 616
 617 \f
 618 /* If mourn is being called in all the right places, this could be say
 619    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 620
 621 static int
 622 ignore (struct bp_target_info *bp_tgt)
 623 {
 624   return 0;
 625 }
 626
 627
 628 /* Okay, let's be honest: threads gleaned from a core file aren't
 629    exactly lively, are they?  On the other hand, if we don't claim
 630    that each & every one is alive, then we don't get any of them
 631    to appear in an "info thread" command, which is quite a useful
 632    behaviour.
 633  */
 634 static int
 635 core_file_thread_alive (ptid_t tid)
 636 {
 637   return 1;
 638 }
 639
 640 /* Ask the current architecture what it knows about this core file.
 641    That will be used, in turn, to pick a better architecture.  This
 642    wrapper could be avoided if targets got a chance to specialize
 643    core_ops.  */
 644
 645 static const struct target_desc *
 646 core_read_description (struct target_ops *target)
 647 {
 648   if (gdbarch_core_read_description_p (current_gdbarch))
 649     return gdbarch_core_read_description (current_gdbarch, target, core_bfd);
 650
 651   return NULL;
 652 }
 653
 654 /* Fill in core_ops with its defined operations and properties.  */
 655
 656 static void
 657 init_core_ops (void)
 658 {
 659   core_ops.to_shortname = "core";
 660   core_ops.to_longname = "Local core dump file";
 661   core_ops.to_doc =
 662     "Use a core file as a target.  Specify the filename of the core file.";
 663   core_ops.to_open = core_open;
 664   core_ops.to_close = core_close;
 665   core_ops.to_attach = find_default_attach;
 666   core_ops.to_detach = core_detach;
 667   core_ops.to_fetch_registers = get_core_registers;
 668   core_ops.to_xfer_partial = core_xfer_partial;
 669   core_ops.deprecated_xfer_memory = xfer_memory;
 670   core_ops.to_files_info = core_files_info;
 671   core_ops.to_insert_breakpoint = ignore;
 672   core_ops.to_remove_breakpoint = ignore;
 673   core_ops.to_create_inferior = find_default_create_inferior;
 674   core_ops.to_thread_alive = core_file_thread_alive;
 675   core_ops.to_read_description = core_read_description;
 676   core_ops.to_stratum = core_stratum;
 677   core_ops.to_has_memory = 1;
 678   core_ops.to_has_stack = 1;
 679   core_ops.to_has_registers = 1;
 680   core_ops.to_magic = OPS_MAGIC;
 681 }
 682
 683 /* non-zero if we should not do the add_target call in
 684    _initialize_corelow; not initialized (i.e., bss) so that
 685    the target can initialize it (i.e., data) if appropriate.
 686    This needs to be set at compile time because we don't know
 687    for sure whether the target's initialize routine is called
 688    before us or after us. */
 689 int coreops_suppress_target;
 690
 691 void
 692 _initialize_corelow (void)
 693 {
 694   init_core_ops ();
 695
 696   if (!coreops_suppress_target)
 697     add_target (&core_ops);
 698 }