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 (struct regcache *, 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 (current_regcache, -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 (struct regcache *regcache,
 421                            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, regcache, -1, contents, size);
 469       return;
 470     }
 471
 472   gdb_assert (core_vec);
 473   core_vec->core_read_registers (regcache, 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 (struct regcache *regcache, int regno)
 487 {
 488   int i;
 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 (regcache,
 499                              ".reg", 0, "general-purpose", 1);
 500   get_core_register_section (regcache,
 501                              ".reg2", 2, "floating-point", 0);
 502   get_core_register_section (regcache,
 503                              ".reg-xfp", 3, "extended floating-point", 0);
 504
 505   /* Supply dummy value for all registers not found in the core.  */
 506   for (i = 0; i < gdbarch_num_regs (current_gdbarch); 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, len,
 527                                                0/*write*/, NULL, ops);
 528       if (writebuf)
 529         return (*ops->deprecated_xfer_memory) (offset, readbuf, len,
 530                                                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     default:
 598       if (ops->beneath != NULL)
 599         return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
 600                                               readbuf, writebuf, offset, len);
 601       return -1;
 602     }
 603 }
 604
 605 \f
 606 /* If mourn is being called in all the right places, this could be say
 607    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 608
 609 static int
 610 ignore (struct bp_target_info *bp_tgt)
 611 {
 612   return 0;
 613 }
 614
 615
 616 /* Okay, let's be honest: threads gleaned from a core file aren't
 617    exactly lively, are they?  On the other hand, if we don't claim
 618    that each & every one is alive, then we don't get any of them
 619    to appear in an "info thread" command, which is quite a useful
 620    behaviour.
 621  */
 622 static int
 623 core_file_thread_alive (ptid_t tid)
 624 {
 625   return 1;
 626 }
 627
 628 /* Fill in core_ops with its defined operations and properties.  */
 629
 630 static void
 631 init_core_ops (void)
 632 {
 633   core_ops.to_shortname = "core";
 634   core_ops.to_longname = "Local core dump file";
 635   core_ops.to_doc =
 636     "Use a core file as a target.  Specify the filename of the core file.";
 637   core_ops.to_open = core_open;
 638   core_ops.to_close = core_close;
 639   core_ops.to_attach = find_default_attach;
 640   core_ops.to_detach = core_detach;
 641   core_ops.to_fetch_registers = get_core_registers;
 642   core_ops.to_xfer_partial = core_xfer_partial;
 643   core_ops.deprecated_xfer_memory = xfer_memory;
 644   core_ops.to_files_info = core_files_info;
 645   core_ops.to_insert_breakpoint = ignore;
 646   core_ops.to_remove_breakpoint = ignore;
 647   core_ops.to_create_inferior = find_default_create_inferior;
 648   core_ops.to_thread_alive = core_file_thread_alive;
 649   core_ops.to_stratum = core_stratum;
 650   core_ops.to_has_memory = 1;
 651   core_ops.to_has_stack = 1;
 652   core_ops.to_has_registers = 1;
 653   core_ops.to_magic = OPS_MAGIC;
 654 }
 655
 656 /* non-zero if we should not do the add_target call in
 657    _initialize_corelow; not initialized (i.e., bss) so that
 658    the target can initialize it (i.e., data) if appropriate.
 659    This needs to be set at compile time because we don't know
 660    for sure whether the target's initialize routine is called
 661    before us or after us. */
 662 int coreops_suppress_target;
 663
 664 void
 665 _initialize_corelow (void)
 666 {
 667   init_core_ops ();
 668
 669   if (!coreops_suppress_target)
 670     add_target (&core_ops);
 671 }