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