| 1 | /* Unexec for DEC alpha. schoepf@sc.ZIB-Berlin.DE (Rainer Schoepf). |
| 2 | |
| 3 | Copyright (C) 1994, 2000 Free Software Foundation, Inc. |
| 4 | |
| 5 | This file is part of GNU Emacs. |
| 6 | |
| 7 | GNU Emacs 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, or (at your option) |
| 10 | any later version. |
| 11 | |
| 12 | GNU Emacs 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 GNU Emacs; see the file COPYING. If not, write to |
| 19 | the Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| 20 | Boston, MA 02111-1307, USA. */ |
| 21 | |
| 22 | \f |
| 23 | #include <config.h> |
| 24 | #include <sys/types.h> |
| 25 | #include <sys/file.h> |
| 26 | #include <sys/stat.h> |
| 27 | #include <sys/mman.h> |
| 28 | #include <stdio.h> |
| 29 | #include <varargs.h> |
| 30 | #include <errno.h> |
| 31 | #ifdef HAVE_STRING_H |
| 32 | #include <string.h> |
| 33 | #endif |
| 34 | #if !defined (__NetBSD__) && !defined (__OpenBSD__) |
| 35 | #include <filehdr.h> |
| 36 | #include <aouthdr.h> |
| 37 | #include <scnhdr.h> |
| 38 | #include <syms.h> |
| 39 | #ifndef __linux__ |
| 40 | # include <reloc.h> |
| 41 | # include <elf_abi.h> |
| 42 | #endif |
| 43 | #else /* __NetBSD__ or __OpenBSD__ */ |
| 44 | /* |
| 45 | * NetBSD/Alpha does not have 'normal' user-land ECOFF support because |
| 46 | * there's no desire to support ECOFF as the executable format in the |
| 47 | * long term. |
| 48 | */ |
| 49 | #include <sys/exec_ecoff.h> |
| 50 | |
| 51 | /* Structures, constants, etc., that NetBSD defines strangely. */ |
| 52 | #define filehdr ecoff_filehdr |
| 53 | #define aouthdr ecoff_aouthdr |
| 54 | #define scnhdr ecoff_scnhdr |
| 55 | #define HDRR struct ecoff_symhdr |
| 56 | #define pHDRR HDRR * |
| 57 | #define cbHDRR sizeof(HDRR) |
| 58 | #ifdef __OpenBSD__ |
| 59 | #define ALPHAMAGIC ECOFF_MAGIC_NATIVE_ALPHA |
| 60 | #else |
| 61 | #define ALPHAMAGIC ECOFF_MAGIC_NETBSD_ALPHA |
| 62 | #endif |
| 63 | #define ZMAGIC ECOFF_ZMAGIC |
| 64 | |
| 65 | /* Misc. constants that NetBSD doesn't define at all. */ |
| 66 | #define ALPHAUMAGIC 0617 |
| 67 | #define _MIPS_NSCNS_MAX 35 |
| 68 | #define STYP_TEXT 0x00000020 |
| 69 | #define STYP_DATA 0x00000040 |
| 70 | #define STYP_BSS 0x00000080 |
| 71 | #define STYP_RDATA 0x00000100 |
| 72 | #define STYP_SDATA 0x00000200 |
| 73 | #define STYP_SBSS 0x00000400 |
| 74 | #define STYP_INIT 0x80000000 |
| 75 | #define _TEXT ".text" |
| 76 | #define _DATA ".data" |
| 77 | #define _BSS ".bss" |
| 78 | #define _INIT ".init" |
| 79 | #define _RDATA ".rdata" |
| 80 | #define _SDATA ".sdata" |
| 81 | #define _SBSS ".sbss" |
| 82 | #endif /* __NetBSD__ || __OpenBSD__ */ |
| 83 | |
| 84 | static void fatal_unexec __P ((char *, char *)); |
| 85 | static void mark_x __P ((char *)); |
| 86 | |
| 87 | static void update_dynamic_symbols __P ((char *, char *, int, struct aouthdr)); |
| 88 | |
| 89 | #define READ(_fd, _buffer, _size, _error_message, _error_arg) \ |
| 90 | errno = EEOF; \ |
| 91 | if (read (_fd, _buffer, _size) != _size) \ |
| 92 | fatal_unexec (_error_message, _error_arg); |
| 93 | |
| 94 | #define WRITE(_fd, _buffer, _size, _error_message, _error_arg) \ |
| 95 | if (write (_fd, _buffer, _size) != _size) \ |
| 96 | fatal_unexec (_error_message, _error_arg); |
| 97 | |
| 98 | #define SEEK(_fd, _position, _error_message, _error_arg) \ |
| 99 | errno = EEOF; \ |
| 100 | if (lseek (_fd, _position, L_SET) != _position) \ |
| 101 | fatal_unexec (_error_message, _error_arg); |
| 102 | |
| 103 | #ifdef HAVE_UNISTD_H |
| 104 | #include <unistd.h> |
| 105 | #else |
| 106 | void *sbrk (); |
| 107 | #endif |
| 108 | |
| 109 | #define EEOF -1 |
| 110 | |
| 111 | static struct scnhdr *text_section; |
| 112 | static struct scnhdr *rel_dyn_section; |
| 113 | static struct scnhdr *dynstr_section; |
| 114 | static struct scnhdr *dynsym_section; |
| 115 | static struct scnhdr *init_section; |
| 116 | static struct scnhdr *finit_section; |
| 117 | static struct scnhdr *rdata_section; |
| 118 | static struct scnhdr *rconst_section; |
| 119 | static struct scnhdr *data_section; |
| 120 | static struct scnhdr *pdata_section; |
| 121 | static struct scnhdr *xdata_section; |
| 122 | static struct scnhdr *got_section; |
| 123 | static struct scnhdr *lit8_section; |
| 124 | static struct scnhdr *lit4_section; |
| 125 | static struct scnhdr *sdata_section; |
| 126 | static struct scnhdr *sbss_section; |
| 127 | static struct scnhdr *bss_section; |
| 128 | |
| 129 | static struct scnhdr old_data_scnhdr; |
| 130 | |
| 131 | static unsigned long Brk; |
| 132 | |
| 133 | struct headers { |
| 134 | struct filehdr fhdr; |
| 135 | struct aouthdr aout; |
| 136 | struct scnhdr section[_MIPS_NSCNS_MAX]; |
| 137 | }; |
| 138 | |
| 139 | |
| 140 | |
| 141 | /* Define name of label for entry point for the dumped executable. */ |
| 142 | |
| 143 | #ifndef DEFAULT_ENTRY_ADDRESS |
| 144 | #define DEFAULT_ENTRY_ADDRESS __start |
| 145 | #endif |
| 146 | \f |
| 147 | void |
| 148 | unexec (new_name, a_name, data_start, bss_start, entry_address) |
| 149 | char *new_name, *a_name; |
| 150 | unsigned long data_start, bss_start, entry_address; |
| 151 | { |
| 152 | int new, old; |
| 153 | char * oldptr; |
| 154 | struct headers ohdr, nhdr; |
| 155 | struct stat stat; |
| 156 | long pagesize, brk; |
| 157 | long newsyms, symrel; |
| 158 | int nread; |
| 159 | int i; |
| 160 | long vaddr, scnptr; |
| 161 | #define BUFSIZE 8192 |
| 162 | char buffer[BUFSIZE]; |
| 163 | |
| 164 | if ((old = open (a_name, O_RDONLY)) < 0) |
| 165 | fatal_unexec ("opening %s", a_name); |
| 166 | |
| 167 | new = creat (new_name, 0666); |
| 168 | if (new < 0) fatal_unexec ("creating %s", new_name); |
| 169 | |
| 170 | if ((fstat (old, &stat) == -1)) |
| 171 | fatal_unexec ("fstat %s", a_name); |
| 172 | |
| 173 | oldptr = (char *)mmap (0, stat.st_size, PROT_READ, MAP_FILE|MAP_SHARED, old, 0); |
| 174 | |
| 175 | if (oldptr == (char *)-1) |
| 176 | fatal_unexec ("mmap %s", a_name); |
| 177 | |
| 178 | close (old); |
| 179 | |
| 180 | /* This is a copy of the a.out header of the original executable */ |
| 181 | |
| 182 | ohdr = (*(struct headers *)oldptr); |
| 183 | |
| 184 | /* This is where we build the new header from the in-memory copy */ |
| 185 | |
| 186 | nhdr = *((struct headers *)TEXT_START); |
| 187 | |
| 188 | /* First do some consistency checks */ |
| 189 | |
| 190 | if (nhdr.fhdr.f_magic != ALPHAMAGIC |
| 191 | && nhdr.fhdr.f_magic != ALPHAUMAGIC) |
| 192 | { |
| 193 | fprintf (stderr, "unexec: input file magic number is %x, not %x or %x.\n", |
| 194 | nhdr.fhdr.f_magic, ALPHAMAGIC, ALPHAUMAGIC); |
| 195 | exit (1); |
| 196 | } |
| 197 | |
| 198 | if (nhdr.fhdr.f_opthdr != sizeof (nhdr.aout)) |
| 199 | { |
| 200 | fprintf (stderr, "unexec: input a.out header is %d bytes, not %d.\n", |
| 201 | nhdr.fhdr.f_opthdr, (int)sizeof (nhdr.aout)); |
| 202 | exit (1); |
| 203 | } |
| 204 | if (nhdr.aout.magic != ZMAGIC) |
| 205 | { |
| 206 | fprintf (stderr, "unexec: input file a.out magic number is %o, not %o.\n", |
| 207 | nhdr.aout.magic, ZMAGIC); |
| 208 | exit (1); |
| 209 | } |
| 210 | |
| 211 | |
| 212 | /* Now check the existence of certain header section and grab |
| 213 | their addresses. */ |
| 214 | |
| 215 | #define CHECK_SCNHDR(ptr, name, flags) \ |
| 216 | ptr = NULL; \ |
| 217 | for (i = 0; i < nhdr.fhdr.f_nscns && !ptr; i++) \ |
| 218 | if (strncmp (nhdr.section[i].s_name, name, 8) == 0) \ |
| 219 | { \ |
| 220 | if (nhdr.section[i].s_flags != flags) \ |
| 221 | fprintf (stderr, "unexec: %x flags (%x expected) in %s section.\n", \ |
| 222 | nhdr.section[i].s_flags, flags, name); \ |
| 223 | ptr = nhdr.section + i; \ |
| 224 | } \ |
| 225 | |
| 226 | CHECK_SCNHDR (text_section, _TEXT, STYP_TEXT); |
| 227 | CHECK_SCNHDR (init_section, _INIT, STYP_INIT); |
| 228 | #ifdef _REL_DYN |
| 229 | CHECK_SCNHDR (rel_dyn_section, _REL_DYN, STYP_REL_DYN); |
| 230 | #endif /* _REL_DYN */ |
| 231 | #ifdef _DYNSYM |
| 232 | CHECK_SCNHDR (dynsym_section, _DYNSYM, STYP_DYNSYM); |
| 233 | #endif /* _REL_DYN */ |
| 234 | #ifdef _DYNSTR |
| 235 | CHECK_SCNHDR (dynstr_section, _DYNSTR, STYP_DYNSTR); |
| 236 | #endif /* _REL_DYN */ |
| 237 | #ifdef _FINI |
| 238 | CHECK_SCNHDR (finit_section, _FINI, STYP_FINI); |
| 239 | #endif /* _FINI */ |
| 240 | CHECK_SCNHDR (rdata_section, _RDATA, STYP_RDATA); |
| 241 | #ifdef _RCONST |
| 242 | CHECK_SCNHDR (rconst_section, _RCONST, STYP_RCONST); |
| 243 | #endif |
| 244 | #ifdef _PDATA |
| 245 | CHECK_SCNHDR (pdata_section, _PDATA, STYP_PDATA); |
| 246 | #endif /* _PDATA */ |
| 247 | #ifdef _GOT |
| 248 | CHECK_SCNHDR (got_section, _GOT, STYP_GOT); |
| 249 | #endif /* _GOT */ |
| 250 | CHECK_SCNHDR (data_section, _DATA, STYP_DATA); |
| 251 | #ifdef _XDATA |
| 252 | CHECK_SCNHDR (xdata_section, _XDATA, STYP_XDATA); |
| 253 | #endif /* _XDATA */ |
| 254 | #ifdef _LIT8 |
| 255 | CHECK_SCNHDR (lit8_section, _LIT8, STYP_LIT8); |
| 256 | CHECK_SCNHDR (lit4_section, _LIT4, STYP_LIT4); |
| 257 | #endif /* _LIT8 */ |
| 258 | CHECK_SCNHDR (sdata_section, _SDATA, STYP_SDATA); |
| 259 | CHECK_SCNHDR (sbss_section, _SBSS, STYP_SBSS); |
| 260 | CHECK_SCNHDR (bss_section, _BSS, STYP_BSS); |
| 261 | |
| 262 | |
| 263 | pagesize = getpagesize (); |
| 264 | brk = (((long) (sbrk (0))) + pagesize - 1) & (-pagesize); |
| 265 | |
| 266 | /* Remember the current break */ |
| 267 | |
| 268 | Brk = brk; |
| 269 | |
| 270 | bcopy (data_section, &old_data_scnhdr, sizeof (old_data_scnhdr)); |
| 271 | |
| 272 | nhdr.aout.dsize = brk - DATA_START; |
| 273 | nhdr.aout.bsize = 0; |
| 274 | if (entry_address == 0) |
| 275 | { |
| 276 | extern DEFAULT_ENTRY_ADDRESS (); |
| 277 | nhdr.aout.entry = (unsigned long)DEFAULT_ENTRY_ADDRESS; |
| 278 | } |
| 279 | else |
| 280 | nhdr.aout.entry = entry_address; |
| 281 | |
| 282 | nhdr.aout.bss_start = nhdr.aout.data_start + nhdr.aout.dsize; |
| 283 | |
| 284 | if (rdata_section != NULL) |
| 285 | { |
| 286 | rdata_section->s_size = data_start - DATA_START; |
| 287 | |
| 288 | /* Adjust start and virtual addresses of rdata_section, too. */ |
| 289 | rdata_section->s_vaddr = DATA_START; |
| 290 | rdata_section->s_paddr = DATA_START; |
| 291 | rdata_section->s_scnptr = text_section->s_scnptr + nhdr.aout.tsize; |
| 292 | } |
| 293 | |
| 294 | data_section->s_vaddr = data_start; |
| 295 | data_section->s_paddr = data_start; |
| 296 | data_section->s_size = brk - data_start; |
| 297 | |
| 298 | if (rdata_section != NULL) |
| 299 | { |
| 300 | data_section->s_scnptr = rdata_section->s_scnptr + rdata_section->s_size; |
| 301 | } |
| 302 | |
| 303 | vaddr = data_section->s_vaddr + data_section->s_size; |
| 304 | scnptr = data_section->s_scnptr + data_section->s_size; |
| 305 | if (lit8_section != NULL) |
| 306 | { |
| 307 | lit8_section->s_vaddr = vaddr; |
| 308 | lit8_section->s_paddr = vaddr; |
| 309 | lit8_section->s_size = 0; |
| 310 | lit8_section->s_scnptr = scnptr; |
| 311 | } |
| 312 | if (lit4_section != NULL) |
| 313 | { |
| 314 | lit4_section->s_vaddr = vaddr; |
| 315 | lit4_section->s_paddr = vaddr; |
| 316 | lit4_section->s_size = 0; |
| 317 | lit4_section->s_scnptr = scnptr; |
| 318 | } |
| 319 | if (sdata_section != NULL) |
| 320 | { |
| 321 | sdata_section->s_vaddr = vaddr; |
| 322 | sdata_section->s_paddr = vaddr; |
| 323 | sdata_section->s_size = 0; |
| 324 | sdata_section->s_scnptr = scnptr; |
| 325 | } |
| 326 | #ifdef _XDATA |
| 327 | if (xdata_section != NULL) |
| 328 | { |
| 329 | xdata_section->s_vaddr = vaddr; |
| 330 | xdata_section->s_paddr = vaddr; |
| 331 | xdata_section->s_size = 0; |
| 332 | xdata_section->s_scnptr = scnptr; |
| 333 | } |
| 334 | #endif |
| 335 | #ifdef _GOT |
| 336 | if (got_section != NULL) |
| 337 | { |
| 338 | bcopy (got_section, buffer, sizeof (struct scnhdr)); |
| 339 | |
| 340 | got_section->s_vaddr = vaddr; |
| 341 | got_section->s_paddr = vaddr; |
| 342 | got_section->s_size = 0; |
| 343 | got_section->s_scnptr = scnptr; |
| 344 | } |
| 345 | #endif /*_GOT */ |
| 346 | if (sbss_section != NULL) |
| 347 | { |
| 348 | sbss_section->s_vaddr = vaddr; |
| 349 | sbss_section->s_paddr = vaddr; |
| 350 | sbss_section->s_size = 0; |
| 351 | sbss_section->s_scnptr = scnptr; |
| 352 | } |
| 353 | if (bss_section != NULL) |
| 354 | { |
| 355 | bss_section->s_vaddr = vaddr; |
| 356 | bss_section->s_paddr = vaddr; |
| 357 | bss_section->s_size = 0; |
| 358 | bss_section->s_scnptr = scnptr; |
| 359 | } |
| 360 | |
| 361 | WRITE (new, (char *)TEXT_START, nhdr.aout.tsize, |
| 362 | "writing text section to %s", new_name); |
| 363 | WRITE (new, (char *)DATA_START, nhdr.aout.dsize, |
| 364 | "writing data section to %s", new_name); |
| 365 | |
| 366 | #ifdef _GOT |
| 367 | #define old_got_section ((struct scnhdr *)buffer) |
| 368 | |
| 369 | if (got_section != NULL) |
| 370 | { |
| 371 | SEEK (new, old_got_section->s_scnptr, |
| 372 | "seeking to start of got_section in %s", new_name); |
| 373 | WRITE (new, oldptr + old_got_section->s_scnptr, old_got_section->s_size, |
| 374 | "writing new got_section of %s", new_name); |
| 375 | SEEK (new, nhdr.aout.tsize + nhdr.aout.dsize, |
| 376 | "seeking to end of data section of %s", new_name); |
| 377 | } |
| 378 | |
| 379 | #undef old_got_section |
| 380 | #endif |
| 381 | |
| 382 | /* |
| 383 | * Construct new symbol table header |
| 384 | */ |
| 385 | |
| 386 | bcopy (oldptr + nhdr.fhdr.f_symptr, buffer, cbHDRR); |
| 387 | |
| 388 | #define symhdr ((pHDRR)buffer) |
| 389 | newsyms = nhdr.aout.tsize + nhdr.aout.dsize; |
| 390 | symrel = newsyms - nhdr.fhdr.f_symptr; |
| 391 | nhdr.fhdr.f_symptr = newsyms; |
| 392 | symhdr->cbLineOffset += symrel; |
| 393 | symhdr->cbDnOffset += symrel; |
| 394 | symhdr->cbPdOffset += symrel; |
| 395 | symhdr->cbSymOffset += symrel; |
| 396 | symhdr->cbOptOffset += symrel; |
| 397 | symhdr->cbAuxOffset += symrel; |
| 398 | symhdr->cbSsOffset += symrel; |
| 399 | symhdr->cbSsExtOffset += symrel; |
| 400 | symhdr->cbFdOffset += symrel; |
| 401 | symhdr->cbRfdOffset += symrel; |
| 402 | symhdr->cbExtOffset += symrel; |
| 403 | |
| 404 | WRITE (new, buffer, cbHDRR, "writing symbol table header of %s", new_name); |
| 405 | |
| 406 | /* |
| 407 | * Copy the symbol table and line numbers |
| 408 | */ |
| 409 | WRITE (new, oldptr + ohdr.fhdr.f_symptr + cbHDRR, |
| 410 | stat.st_size - ohdr.fhdr.f_symptr - cbHDRR, |
| 411 | "writing symbol table of %s", new_name); |
| 412 | |
| 413 | #ifdef _REL_DYN |
| 414 | if (rel_dyn_section) |
| 415 | update_dynamic_symbols (oldptr, new_name, new, nhdr.aout); |
| 416 | #endif |
| 417 | |
| 418 | #undef symhdr |
| 419 | |
| 420 | SEEK (new, 0, "seeking to start of header in %s", new_name); |
| 421 | WRITE (new, &nhdr, sizeof (nhdr), |
| 422 | "writing header of %s", new_name); |
| 423 | |
| 424 | close (old); |
| 425 | close (new); |
| 426 | mark_x (new_name); |
| 427 | } |
| 428 | |
| 429 | |
| 430 | static void |
| 431 | update_dynamic_symbols (old, new_name, new, aout) |
| 432 | char *old; /* Pointer to old executable */ |
| 433 | char *new_name; /* Name of new executable */ |
| 434 | int new; /* File descriptor for new executable */ |
| 435 | struct aouthdr aout; /* a.out info from the file header */ |
| 436 | { |
| 437 | #if !defined (__linux__) && !defined (__NetBSD__) && !defined (__OpenBSD__) |
| 438 | |
| 439 | typedef struct dynrel_info { |
| 440 | char * addr; |
| 441 | unsigned type:8; |
| 442 | unsigned index:24; |
| 443 | unsigned info:8; |
| 444 | unsigned pad:8; |
| 445 | } dr_info; |
| 446 | |
| 447 | int nsyms = rel_dyn_section->s_size / sizeof (struct dynrel_info); |
| 448 | int i; |
| 449 | dr_info * rd_base = (dr_info *) (old + rel_dyn_section->s_scnptr); |
| 450 | Elf32_Sym * ds_base = (Elf32_Sym *) (old + dynsym_section->s_scnptr); |
| 451 | |
| 452 | for (i = 0; i < nsyms; i++) { |
| 453 | register Elf32_Sym x; |
| 454 | |
| 455 | if (rd_base[i].index == 0) |
| 456 | continue; |
| 457 | |
| 458 | x = ds_base[rd_base[i].index]; |
| 459 | |
| 460 | #if 0 |
| 461 | fprintf (stderr, "Object inspected: %s, addr = %lx, shndx = %x", |
| 462 | old + dynstr_section->s_scnptr + x.st_name, rd_base[i].addr, x.st_shndx); |
| 463 | #endif |
| 464 | |
| 465 | |
| 466 | if ((ELF32_ST_BIND (x.st_info) == STB_GLOBAL) |
| 467 | && (x.st_shndx == 0) |
| 468 | /* && (x.st_value == NULL) */ |
| 469 | ) { |
| 470 | /* OK, this is probably a reference to an object in a shared |
| 471 | library, so copy the old value. This is done in several steps: |
| 472 | 1. reladdr is the address of the location in question relative to |
| 473 | the start of the data section, |
| 474 | 2. oldref is the addr is the mapped in temacs executable, |
| 475 | 3. newref is the address of the location in question in the |
| 476 | undumped executable, |
| 477 | 4. len is the size of the object reference in bytes -- |
| 478 | currently only 4 (long) and 8 (quad) are supported. |
| 479 | */ |
| 480 | register unsigned long reladdr = (long)rd_base[i].addr - old_data_scnhdr.s_vaddr; |
| 481 | char * oldref = old + old_data_scnhdr.s_scnptr + reladdr; |
| 482 | unsigned long newref = aout.tsize + reladdr; |
| 483 | int len; |
| 484 | |
| 485 | #if 0 |
| 486 | fprintf (stderr, "...relocated\n"); |
| 487 | #endif |
| 488 | |
| 489 | if (rd_base[i].type == R_REFLONG) |
| 490 | len = 4; |
| 491 | else if (rd_base[i].type == R_REFQUAD) |
| 492 | len = 8; |
| 493 | else |
| 494 | fatal_unexec ("unrecognized relocation type in .dyn.rel section (symbol #%d)", i); |
| 495 | |
| 496 | SEEK (new, newref, "seeking to dynamic symbol in %s", new_name); |
| 497 | WRITE (new, oldref, len, "writing old dynrel info in %s", new_name); |
| 498 | } |
| 499 | |
| 500 | #if 0 |
| 501 | else |
| 502 | fprintf (stderr, "...not relocated\n"); |
| 503 | #endif |
| 504 | |
| 505 | } |
| 506 | |
| 507 | #endif /* not __linux__ and not __NetBSD__ and not __OpenBSD__ */ |
| 508 | } |
| 509 | |
| 510 | \f |
| 511 | /* |
| 512 | * mark_x |
| 513 | * |
| 514 | * After successfully building the new a.out, mark it executable |
| 515 | */ |
| 516 | |
| 517 | static void |
| 518 | mark_x (name) |
| 519 | char *name; |
| 520 | { |
| 521 | struct stat sbuf; |
| 522 | int um = umask (777); |
| 523 | umask (um); |
| 524 | if (stat (name, &sbuf) < 0) |
| 525 | fatal_unexec ("getting protection on %s", name); |
| 526 | sbuf.st_mode |= 0111 & ~um; |
| 527 | if (chmod (name, sbuf.st_mode) < 0) |
| 528 | fatal_unexec ("setting protection on %s", name); |
| 529 | } |
| 530 | |
| 531 | static void |
| 532 | fatal_unexec (s, arg) |
| 533 | char *s; |
| 534 | char *arg; |
| 535 | { |
| 536 | if (errno == EEOF) |
| 537 | fputs ("unexec: unexpected end of file, ", stderr); |
| 538 | else |
| 539 | fprintf (stderr, "unexec: %s, ", strerror (errno)); |
| 540 | fprintf (stderr, s, arg); |
| 541 | fputs (".\n", stderr); |
| 542 | exit (1); |
| 543 | } |