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