1 /* BFD back end for SCO5 core files (U-area and raw sections) 2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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, _raw_size, vma, filepos) 56 bfd *abfd; 57 const char *name; 58 flagword flags; 59 bfd_size_type _raw_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->_raw_size = _raw_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 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 int 342 sco5_core_file_failing_signal (ignore_abfd) 343 bfd *ignore_abfd; 344 { 345 return ((ignore_abfd->tdata.sco5_core_data->u.u_sysabort != 0) 346 ? ignore_abfd->tdata.sco5_core_data->u.u_sysabort 347 : -1); 348 } 349 350 bfd_boolean 351 sco5_core_file_matches_executable_p (core_bfd, exec_bfd) 352 bfd *core_bfd ATTRIBUTE_UNUSED; 353 bfd *exec_bfd ATTRIBUTE_UNUSED; 354 { 355 return TRUE; /* FIXME, We have no way of telling at this point */ 356 } 357 358 /* If somebody calls any byte-swapping routines, shoot them. */ 359 static void 360 swap_abort () 361 { 362 abort (); /* This way doesn't require any declaration for ANSI to fuck up */ 363 } 364 365 #define NO_GET ((bfd_vma (*) (const void *)) swap_abort) 366 #define NO_PUT ((void (*) (bfd_vma, void *)) swap_abort) 367 #define NO_GETS ((bfd_signed_vma (*) (const void *)) swap_abort) 368 #define NO_GET64 ((bfd_uint64_t (*) (const void *)) swap_abort) 369 #define NO_PUT64 ((void (*) (bfd_uint64_t, void *)) swap_abort) 370 #define NO_GETS64 ((bfd_int64_t (*) (const void *)) swap_abort) 371 372 const bfd_target sco5_core_vec = 373 { 374 "sco5-core", 375 bfd_target_unknown_flavour, 376 BFD_ENDIAN_LITTLE, /* target byte order */ 377 BFD_ENDIAN_LITTLE, /* target headers byte order */ 378 (HAS_RELOC | EXEC_P | /* object flags */ 379 HAS_LINENO | HAS_DEBUG | 380 HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), 381 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ 382 0, /* symbol prefix */ 383 ' ', /* ar_pad_char */ 384 16, /* ar_max_namelen */ 385 NO_GET64, NO_GETS64, NO_PUT64, /* 64 bit data */ 386 NO_GET, NO_GETS, NO_PUT, /* 32 bit data */ 387 NO_GET, NO_GETS, NO_PUT, /* 16 bit data */ 388 NO_GET64, NO_GETS64, NO_PUT64, /* 64 bit hdrs */ 389 NO_GET, NO_GETS, NO_PUT, /* 32 bit hdrs */ 390 NO_GET, NO_GETS, NO_PUT, /* 16 bit hdrs */ 391 392 { /* bfd_check_format */ 393 _bfd_dummy_target, /* unknown format */ 394 _bfd_dummy_target, /* object file */ 395 _bfd_dummy_target, /* archive */ 396 sco5_core_file_p /* a core file */ 397 }, 398 { /* bfd_set_format */ 399 bfd_false, bfd_false, 400 bfd_false, bfd_false 401 }, 402 { /* bfd_write_contents */ 403 bfd_false, bfd_false, 404 bfd_false, bfd_false 405 }, 406 407 BFD_JUMP_TABLE_GENERIC (_bfd_generic), 408 BFD_JUMP_TABLE_COPY (_bfd_generic), 409 BFD_JUMP_TABLE_CORE (sco5), 410 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive), 411 BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols), 412 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs), 413 BFD_JUMP_TABLE_WRITE (_bfd_generic), 414 BFD_JUMP_TABLE_LINK (_bfd_nolink), 415 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 416 417 NULL, 418 419 (PTR) 0 /* backend_data */ 420 }; 421