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