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