bfd/sco5-core.c

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