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