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 (target_signal_from_host (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   if (ontop)
 371     {
 372       /* Fetch all registers from core file.  */
 373       target_fetch_registers (get_current_regcache (), -1);
 374
 375       /* Now, set up the frame cache, and print the top of stack.  */
 376       reinit_frame_cache ();
 377       print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 378     }
 379   else
 380     {
 381       warning (
 382                 "you won't be able to access this core file until you terminate\n\
 383 your %s; do ``info files''", target_longname);
 384     }
 385 }
 386
 387 static void
 388 core_detach (char *args, int from_tty)
 389 {
 390   if (args)
 391     error (_("Too many arguments"));
 392   unpush_target (&core_ops);
 393   reinit_frame_cache ();
 394   if (from_tty)
 395     printf_filtered (_("No core file now.\n"));
 396 }
 397
 398
 399 /* Try to retrieve registers from a section in core_bfd, and supply
 400    them to core_vec->core_read_registers, as the register set numbered
 401    WHICH.
 402
 403    If inferior_ptid is zero, do the single-threaded thing: look for a
 404    section named NAME.  If inferior_ptid is non-zero, do the
 405    multi-threaded thing: look for a section named "NAME/PID", where
 406    PID is the shortest ASCII decimal representation of inferior_ptid.
 407
 408    HUMAN_NAME is a human-readable name for the kind of registers the
 409    NAME section contains, for use in error messages.
 410
 411    If REQUIRED is non-zero, print an error if the core file doesn't
 412    have a section by the appropriate name.  Otherwise, just do nothing.  */
 413
 414 static void
 415 get_core_register_section (struct regcache *regcache,
 416                            char *name,
 417                            int which,
 418                            char *human_name,
 419                            int required)
 420 {
 421   static char *section_name = NULL;
 422   struct bfd_section *section;
 423   bfd_size_type size;
 424   char *contents;
 425
 426   xfree (section_name);
 427   if (PIDGET (inferior_ptid))
 428     section_name = xstrprintf ("%s/%d", name, PIDGET (inferior_ptid));
 429   else
 430     section_name = xstrdup (name);
 431
 432   section = bfd_get_section_by_name (core_bfd, section_name);
 433   if (! section)
 434     {
 435       if (required)
 436         warning (_("Couldn't find %s registers in core file."), human_name);
 437       return;
 438     }
 439
 440   size = bfd_section_size (core_bfd, section);
 441   contents = alloca (size);
 442   if (! bfd_get_section_contents (core_bfd, section, contents,
 443                                   (file_ptr) 0, size))
 444     {
 445       warning (_("Couldn't read %s registers from `%s' section in core file."),
 446                human_name, name);
 447       return;
 448     }
 449
 450   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 451     {
 452       const struct regset *regset;
 453
 454       regset = gdbarch_regset_from_core_section (core_gdbarch, name, size);
 455       if (regset == NULL)
 456         {
 457           if (required)
 458             warning (_("Couldn't recognize %s registers in core file."),
 459                      human_name);
 460           return;
 461         }
 462
 463       regset->supply_regset (regset, regcache, -1, contents, size);
 464       return;
 465     }
 466
 467   gdb_assert (core_vec);
 468   core_vec->core_read_registers (regcache, contents, size, which,
 469                                  ((CORE_ADDR)
 470                                   bfd_section_vma (core_bfd, section)));
 471 }
 472
 473
 474 /* Get the registers out of a core file.  This is the machine-
 475    independent part.  Fetch_core_registers is the machine-dependent
 476    part, typically implemented in the xm-file for each architecture.  */
 477
 478 /* We just get all the registers, so we don't use regno.  */
 479
 480 static void
 481 get_core_registers (struct regcache *regcache, int regno)
 482 {
 483   int i;
 484
 485   if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 486       && (core_vec == NULL || core_vec->core_read_registers == NULL))
 487     {
 488       fprintf_filtered (gdb_stderr,
 489                      "Can't fetch registers from this type of core file\n");
 490       return;
 491     }
 492
 493   get_core_register_section (regcache,
 494                              ".reg", 0, "general-purpose", 1);
 495   get_core_register_section (regcache,
 496                              ".reg2", 2, "floating-point", 0);
 497   get_core_register_section (regcache,
 498                              ".reg-xfp", 3, "extended floating-point", 0);
 499   get_core_register_section (regcache,
 500                              ".reg-ppc-vmx", 3, "ppc Altivec", 0);
 501
 502   /* Supply dummy value for all registers not found in the core.  */
 503   for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 504     if (!regcache_valid_p (regcache, i))
 505       regcache_raw_supply (regcache, i, NULL);
 506 }
 507
 508 static void
 509 core_files_info (struct target_ops *t)
 510 {
 511   print_section_info (t, core_bfd);
 512 }
 513 \f
 514 static LONGEST
 515 core_xfer_partial (struct target_ops *ops, enum target_object object,
 516                    const char *annex, gdb_byte *readbuf,
 517                    const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
 518 {
 519   switch (object)
 520     {
 521     case TARGET_OBJECT_MEMORY:
 522       if (readbuf)
 523         return (*ops->deprecated_xfer_memory) (offset, readbuf,
 524                                                len, 0/*read*/, NULL, ops);
 525       if (writebuf)
 526         return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
 527                                                len, 1/*write*/, NULL, ops);
 528       return -1;
 529
 530     case TARGET_OBJECT_AUXV:
 531       if (readbuf)
 532         {
 533           /* When the aux vector is stored in core file, BFD
 534              represents this with a fake section called ".auxv".  */
 535
 536           struct bfd_section *section;
 537           bfd_size_type size;
 538           char *contents;
 539
 540           section = bfd_get_section_by_name (core_bfd, ".auxv");
 541           if (section == NULL)
 542             return -1;
 543
 544           size = bfd_section_size (core_bfd, section);
 545           if (offset >= size)
 546             return 0;
 547           size -= offset;
 548           if (size > len)
 549             size = len;
 550           if (size > 0
 551               && !bfd_get_section_contents (core_bfd, section, readbuf,
 552                                             (file_ptr) offset, size))
 553             {
 554               warning (_("Couldn't read NT_AUXV note in core file."));
 555               return -1;
 556             }
 557
 558           return size;
 559         }
 560       return -1;
 561
 562     case TARGET_OBJECT_WCOOKIE:
 563       if (readbuf)
 564         {
 565           /* When the StackGhost cookie is stored in core file, BFD
 566              represents this with a fake section called ".wcookie".  */
 567
 568           struct bfd_section *section;
 569           bfd_size_type size;
 570           char *contents;
 571
 572           section = bfd_get_section_by_name (core_bfd, ".wcookie");
 573           if (section == NULL)
 574             return -1;
 575
 576           size = bfd_section_size (core_bfd, section);
 577           if (offset >= size)
 578             return 0;
 579           size -= offset;
 580           if (size > len)
 581             size = len;
 582           if (size > 0
 583               && !bfd_get_section_contents (core_bfd, section, readbuf,
 584                                             (file_ptr) offset, size))
 585             {
 586               warning (_("Couldn't read StackGhost cookie in core file."));
 587               return -1;
 588             }
 589
 590           return size;
 591         }
 592       return -1;
 593
 594     case TARGET_OBJECT_LIBRARIES:
 595       if (core_gdbarch
 596           && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
 597         {
 598           if (writebuf)
 599             return -1;
 600           return
 601             gdbarch_core_xfer_shared_libraries (core_gdbarch,
 602                                                 readbuf, offset, len);
 603         }
 604       /* FALL THROUGH */
 605
 606     default:
 607       if (ops->beneath != NULL)
 608         return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
 609                                               readbuf, writebuf, offset, len);
 610       return -1;
 611     }
 612 }
 613
 614 \f
 615 /* If mourn is being called in all the right places, this could be say
 616    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 617
 618 static int
 619 ignore (struct bp_target_info *bp_tgt)
 620 {
 621   return 0;
 622 }
 623
 624
 625 /* Okay, let's be honest: threads gleaned from a core file aren't
 626    exactly lively, are they?  On the other hand, if we don't claim
 627    that each & every one is alive, then we don't get any of them
 628    to appear in an "info thread" command, which is quite a useful
 629    behaviour.
 630  */
 631 static int
 632 core_file_thread_alive (ptid_t tid)
 633 {
 634   return 1;
 635 }
 636
 637 /* Ask the current architecture what it knows about this core file.
 638    That will be used, in turn, to pick a better architecture.  This
 639    wrapper could be avoided if targets got a chance to specialize
 640    core_ops.  */
 641
 642 static const struct target_desc *
 643 core_read_description (struct target_ops *target)
 644 {
 645   if (gdbarch_core_read_description_p (current_gdbarch))
 646     return gdbarch_core_read_description (current_gdbarch, target, core_bfd);
 647
 648   return NULL;
 649 }
 650
 651 /* Fill in core_ops with its defined operations and properties.  */
 652
 653 static void
 654 init_core_ops (void)
 655 {
 656   core_ops.to_shortname = "core";
 657   core_ops.to_longname = "Local core dump file";
 658   core_ops.to_doc =
 659     "Use a core file as a target.  Specify the filename of the core file.";
 660   core_ops.to_open = core_open;
 661   core_ops.to_close = core_close;
 662   core_ops.to_attach = find_default_attach;
 663   core_ops.to_detach = core_detach;
 664   core_ops.to_fetch_registers = get_core_registers;
 665   core_ops.to_xfer_partial = core_xfer_partial;
 666   core_ops.deprecated_xfer_memory = xfer_memory;
 667   core_ops.to_files_info = core_files_info;
 668   core_ops.to_insert_breakpoint = ignore;
 669   core_ops.to_remove_breakpoint = ignore;
 670   core_ops.to_create_inferior = find_default_create_inferior;
 671   core_ops.to_thread_alive = core_file_thread_alive;
 672   core_ops.to_read_description = core_read_description;
 673   core_ops.to_stratum = core_stratum;
 674   core_ops.to_has_memory = 1;
 675   core_ops.to_has_stack = 1;
 676   core_ops.to_has_registers = 1;
 677   core_ops.to_magic = OPS_MAGIC;
 678 }
 679
 680 /* non-zero if we should not do the add_target call in
 681    _initialize_corelow; not initialized (i.e., bss) so that
 682    the target can initialize it (i.e., data) if appropriate.
 683    This needs to be set at compile time because we don't know
 684    for sure whether the target's initialize routine is called
 685    before us or after us. */
 686 int coreops_suppress_target;
 687
 688 void
 689 _initialize_corelow (void)
 690 {
 691   init_core_ops ();
 692
 693   if (!coreops_suppress_target)
 694     add_target (&core_ops);
 695 }