bfd/sco5-core.c

   1 /* BFD back end for SCO5 core files (U-area and raw sections)
   2    Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   3    Written by Jouke Numan <jnuman@hiscom.nl>
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24 #include "libaout.h"            /* BFD a.out internal data structures */
  25
  26 #include <stdio.h>
  27 #include <sys/types.h>
  28 #include <sys/param.h>
  29 #include <sys/dir.h>
  30 #include <signal.h>
  31
  32 #include <sys/user.h>           /* After a.out.h  */
  33 #include <sys/paccess.h>
  34 #include <sys/region.h>
  35
  36 struct sco5_core_struct
  37 {
  38   struct user u;
  39 };
  40
  41 /* forward declarations */
  42
  43 static asection *make_bfd_asection
  44   PARAMS ((bfd *, const char *, flagword, bfd_size_type, bfd_vma, file_ptr));
  45 static struct user *read_uarea PARAMS ((bfd *, int));
  46 const bfd_target *sco5_core_file_p PARAMS ((bfd *abfd));
  47 char *sco5_core_file_failing_command PARAMS ((bfd *abfd));
  48 int sco5_core_file_failing_signal PARAMS ((bfd *abfd));
  49 bfd_boolean sco5_core_file_matches_executable_p
  50   PARAMS ((bfd *core_bfd, bfd *exec_bfd));
  51 static void swap_abort PARAMS ((void));
  52
  53 static asection *
  54 make_bfd_asection (abfd, name, flags, _raw_size, vma, filepos)
  55      bfd *abfd;
  56      const char *name;
  57      flagword flags;
  58      bfd_size_type _raw_size;
  59      bfd_vma vma;
  60      file_ptr filepos;
  61 {
  62   asection *asect;
  63
  64   asect = bfd_make_section_anyway (abfd, name);
  65   if (!asect)
  66     return NULL;
  67   asect->flags = flags;
  68   asect->_raw_size = _raw_size;
  69   asect->vma = vma;
  70   asect->filepos = filepos;
  71   asect->alignment_power = 2;
  72
  73   return asect;
  74 }
  75
  76 static struct user *
  77 read_uarea(abfd, filepos)
  78      bfd *abfd;
  79      int filepos;
  80
  81 {
  82   struct sco5_core_struct *rawptr;
  83   bfd_size_type amt = sizeof (struct sco5_core_struct);
  84
  85   rawptr = (struct sco5_core_struct *) bfd_zmalloc (amt);
  86   if (rawptr == NULL)
  87     return NULL;
  88
  89   abfd->tdata.sco5_core_data = rawptr;
  90
  91   if (bfd_seek (abfd, (file_ptr) filepos, SEEK_SET) != 0
  92       || bfd_bread ((void *) &rawptr->u, (bfd_size_type) sizeof rawptr->u,
  93                    abfd) != sizeof rawptr->u)
  94     {
  95       bfd_set_error (bfd_error_wrong_format);
  96       return NULL;
  97     }
  98
  99   /* Sanity check perhaps??? */
 100   if (rawptr->u.u_dsize > 0x1000000)    /* Remember, it's in pages...  */
 101     {
 102       bfd_set_error (bfd_error_wrong_format);
 103       return NULL;
 104     }
 105   if (rawptr->u.u_ssize > 0x1000000)
 106     {
 107       bfd_set_error (bfd_error_wrong_format);
 108       return NULL;
 109     }
 110   return &rawptr->u;
 111 }
 112
 113 /* ARGSUSED */
 114 const bfd_target *
 115 sco5_core_file_p (abfd)
 116      bfd *abfd;
 117 {
 118   int coffset_siz, val, nsecs, cheadoffs;
 119   int coresize;
 120   struct user *u;
 121   struct coreoffsets coffsets;
 122   struct coresecthead chead;
 123   char *secname;
 124   flagword flags;
 125
 126   /* Read coreoffsets region at end of core (see core(FP)) */
 127
 128   {
 129     FILE *stream = bfd_cache_lookup (abfd);
 130     struct stat statbuf;
 131     if (stream == NULL)
 132       return NULL;
 133     if (fstat (fileno (stream), &statbuf) < 0)
 134       {
 135         bfd_set_error (bfd_error_system_call);
 136         return NULL;
 137       }
 138     coresize = statbuf.st_size;
 139   }
 140   /* Last long in core is sizeof struct coreoffsets, read it */
 141   if ((bfd_seek (abfd, (file_ptr) (coresize - sizeof coffset_siz),
 142                  SEEK_SET) != 0)
 143       || bfd_bread ((void *) &coffset_siz, (bfd_size_type) sizeof coffset_siz,
 144                    abfd) != sizeof coffset_siz)
 145     {
 146       bfd_set_error (bfd_error_wrong_format);
 147       return NULL;
 148     }
 149
 150   /* Use it to seek start of coreoffsets region, read it and determine
 151      validity */
 152   if ((bfd_seek (abfd, (file_ptr) (coresize - coffset_siz), SEEK_SET) != 0)
 153       || (bfd_bread ((void *) &coffsets, (bfd_size_type) sizeof coffsets, abfd)
 154           != sizeof coffsets)
 155       || ((coffsets.u_info != 1) && (coffsets.u_info != C_VERSION)))
 156     {
 157       bfd_set_error (bfd_error_wrong_format);
 158       return NULL;
 159     }
 160
 161   if (coffsets.u_info == 1)
 162     {
 163       /* Old version, no section heads, read info from user struct */
 164
 165       u = read_uarea (abfd, coffsets.u_user);
 166       if (! u)
 167         goto fail;
 168
 169       if (!make_bfd_asection (abfd, ".reg", SEC_HAS_CONTENTS,
 170                               (bfd_size_type) coffsets.u_usize,
 171                               0 - (bfd_vma) u->u_ar0,
 172                               (file_ptr) coffsets.u_user))
 173         goto fail;
 174
 175       if (!make_bfd_asection (abfd, ".data",
 176                               SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
 177                               ((bfd_size_type) u->u_exdata.ux_dsize
 178                                + u->u_exdata.ux_bsize),
 179                               (bfd_vma) u->u_exdata.ux_datorg,
 180                               (file_ptr) coffsets.u_data))
 181         goto fail;
 182
 183       if (!make_bfd_asection (abfd, ".stack",
 184                               SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
 185                               (bfd_size_type) u->u_ssize * NBPC,
 186                               (bfd_vma) u->u_sub,
 187                               (file_ptr) coffsets.u_stack))
 188         goto fail;
 189
 190       return abfd->xvec;                /* Done for version 1 */
 191     }
 192
 193   /* Immediately before coreoffsets region is a long with offset in core
 194      to first coresecthead (CORES_OFFSETS), the long before this is the
 195      number of section heads in the list. Read both longs and read the
 196      coresecthead and check its validity */
 197
 198   if ((bfd_seek (abfd,
 199                  (file_ptr) (coresize - coffset_siz - 2 * sizeof coffset_siz),
 200                  SEEK_SET) != 0)
 201       || (bfd_bread ((void *) &nsecs, (bfd_size_type) sizeof nsecs, abfd)
 202           != sizeof nsecs)
 203       || (bfd_bread ((void *) &cheadoffs, (bfd_size_type) sizeof cheadoffs,
 204                     abfd) != sizeof cheadoffs)
 205       || (bfd_seek (abfd, (file_ptr) cheadoffs, SEEK_SET) != 0)
 206       || (bfd_bread ((void *) &chead, (bfd_size_type) sizeof chead, abfd)
 207           != sizeof chead)
 208       || (chead.cs_stype != CORES_OFFSETS)
 209       || (chead.cs_x.csx_magic != COREMAGIC_NUMBER))
 210     {
 211       bfd_set_error (bfd_error_wrong_format);
 212       goto fail;
 213     }
 214
 215   /* OK, we believe you.  You're a core file (sure, sure).  */
 216
 217   /* Now loop over all regions and map them */
 218   nsecs--;                              /* We've seen CORES_OFFSETS already */
 219   for (; nsecs; nsecs--)
 220     {
 221       if ((bfd_seek (abfd, (file_ptr) chead.cs_hseek, SEEK_SET) != 0)
 222           || (bfd_bread ((void *) &chead, (bfd_size_type) sizeof chead, abfd)
 223               != sizeof chead))
 224         {
 225           bfd_set_error (bfd_error_wrong_format);
 226           goto fail;
 227         }
 228
 229       switch (chead.cs_stype)
 230         {
 231         case CORES_MAGIC:                       /* Core header, check magic */
 232           if (chead.cs_x.csx_magic != COREMAGIC_NUMBER)
 233             {
 234               bfd_set_error (bfd_error_wrong_format);
 235               goto fail;
 236             }
 237           secname = NULL;
 238           nsecs++;                              /* MAGIC not in section cnt!*/
 239           break;
 240         case CORES_UAREA:                       /* U-area, read in tdata */
 241           u = read_uarea (abfd, chead.cs_sseek);
 242           if (! u)
 243             goto fail;
 244
 245           /* This is tricky.  As the "register section", we give them
 246              the entire upage and stack.  u.u_ar0 points to where
 247              "register 0" is stored.  There are two tricks with this,
 248              though.  One is that the rest of the registers might be
 249              at positive or negative (or both) displacements from
 250              *u_ar0.  The other is that u_ar0 is sometimes an absolute
 251              address in kernel memory, and on other systems it is an
 252              offset from the beginning of the `struct user'.
 253
 254              As a practical matter, we don't know where the registers
 255              actually are, so we have to pass the whole area to GDB.
 256              We encode the value of u_ar0 by setting the .regs section
 257              up so that its virtual memory address 0 is at the place
 258              pointed to by u_ar0 (by setting the vma of the start of
 259              the section to -u_ar0).  GDB uses this info to locate the
 260              regs, using minor trickery to get around the
 261              offset-or-absolute-addr problem.  */
 262
 263           chead.cs_vaddr = 0 - (bfd_vma) u->u_ar0;
 264
 265           secname = ".reg";
 266           flags = SEC_HAS_CONTENTS;
 267
 268           break;
 269         case CORES_PREGION:                     /* A program region, map it */
 270           switch (chead.cs_x.csx_preg.csxp_rtyp)
 271             {
 272             case PT_DATA:
 273               secname = ".data";        /* Data region.          */
 274               break;
 275             case PT_STACK:
 276               secname = ".stack";       /* Stack region.         */
 277               break;
 278             case PT_SHMEM:
 279               secname = ".shmem";       /* Shared memory         */
 280               break;
 281             case PT_LIBDAT:
 282               secname = ".libdat";      /* Shared library data   */
 283               break;
 284             case PT_V86:
 285               secname = ".virt86";      /* Virtual 8086 mode     */
 286               break;
 287             case PT_SHFIL:
 288               secname = ".mmfile";      /* Memory mapped file    */
 289               break;
 290             case PT_XDATA0:
 291               secname = ".Xdat0";       /* XENIX data region, virtual 0 */
 292               break;
 293             default:
 294               secname = "";
 295             }
 296           flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
 297           break;
 298         case CORES_PROC:                        /* struct proc */
 299         case CORES_ITIMER:                      /* interval timers */
 300         case CORES_SCOUTSNAME:                  /* struct scoutsname */
 301           secname = NULL;       /* Ignore these */
 302           break;
 303         default:
 304           (*_bfd_error_handler) ("Unhandled SCO core file section type %d\n",
 305                                  chead.cs_stype);
 306           continue;
 307         }
 308
 309       if (secname
 310           && !make_bfd_asection (abfd, secname, flags,
 311                                  (bfd_size_type) chead.cs_vsize,
 312                                  (bfd_vma) chead.cs_vaddr,
 313                                  (file_ptr) chead.cs_sseek))
 314         goto fail;
 315
 316     }
 317
 318   return abfd->xvec;
 319
 320  fail:
 321   if (abfd->tdata.any)
 322     {
 323       bfd_release (abfd, abfd->tdata.any);
 324       abfd->tdata.any = NULL;
 325     }
 326   bfd_section_list_clear (abfd);
 327   return NULL;
 328 }
 329
 330 char *
 331 sco5_core_file_failing_command (abfd)
 332      bfd *abfd;
 333 {
 334   char *com = abfd->tdata.sco5_core_data->u.u_comm;
 335   if (*com)
 336     return com;
 337   else
 338     return NULL;
 339 }
 340
 341 /* ARGSUSED */
 342 int
 343 sco5_core_file_failing_signal (ignore_abfd)
 344      bfd *ignore_abfd;
 345 {
 346   return ((ignore_abfd->tdata.sco5_core_data->u.u_sysabort != 0)
 347           ? ignore_abfd->tdata.sco5_core_data->u.u_sysabort
 348           : -1);
 349 }
 350
 351 /* ARGSUSED */
 352 bfd_boolean
 353 sco5_core_file_matches_executable_p  (core_bfd, exec_bfd)
 354      bfd *core_bfd ATTRIBUTE_UNUSED;
 355      bfd *exec_bfd ATTRIBUTE_UNUSED;
 356 {
 357   return TRUE;          /* FIXME, We have no way of telling at this point */
 358 }
 359
 360 /* If somebody calls any byte-swapping routines, shoot them.  */
 361 static void
 362 swap_abort ()
 363 {
 364   abort (); /* This way doesn't require any declaration for ANSI to fuck up */
 365 }
 366 #define NO_GET  ((bfd_vma (*) PARAMS ((   const bfd_byte *))) swap_abort )
 367 #define NO_PUT  ((void    (*) PARAMS ((bfd_vma, bfd_byte *))) swap_abort )
 368 #define NO_SIGNED_GET \
 369   ((bfd_signed_vma (*) PARAMS ((const bfd_byte *))) swap_abort )
 370
 371 const bfd_target sco5_core_vec =
 372   {
 373     "sco5-core",
 374     bfd_target_unknown_flavour,
 375     BFD_ENDIAN_LITTLE,         /* target byte order */
 376     BFD_ENDIAN_LITTLE,         /* target headers byte order */
 377     (HAS_RELOC | EXEC_P |       /* object flags */
 378      HAS_LINENO | HAS_DEBUG |
 379      HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 380     (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 381     0,                                                     /* symbol prefix */
 382     ' ',                                                   /* ar_pad_char */
 383     16,                                                    /* ar_max_namelen */
 384     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 64 bit data */
 385     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 32 bit data */
 386     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 bit data */
 387     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 64 bit hdrs */
 388     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 32 bit hdrs */
 389     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 bit hdrs */
 390
 391     {                           /* bfd_check_format */
 392      _bfd_dummy_target,         /* unknown format */
 393      _bfd_dummy_target,         /* object file */
 394      _bfd_dummy_target,         /* archive */
 395      sco5_core_file_p           /* a core file */
 396     },
 397     {                           /* bfd_set_format */
 398      bfd_false, bfd_false,
 399      bfd_false, bfd_false
 400     },
 401     {                           /* bfd_write_contents */
 402      bfd_false, bfd_false,
 403      bfd_false, bfd_false
 404     },
 405
 406     BFD_JUMP_TABLE_GENERIC (_bfd_generic),
 407     BFD_JUMP_TABLE_COPY (_bfd_generic),
 408     BFD_JUMP_TABLE_CORE (sco5),
 409     BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
 410     BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
 411     BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 412     BFD_JUMP_TABLE_WRITE (_bfd_generic),
 413     BFD_JUMP_TABLE_LINK (_bfd_nolink),
 414     BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 415
 416     NULL,
 417
 418     (PTR) 0                     /* backend_data */
 419 };