~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/mips/boot/elf2ecoff.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (c) 1995
  3  *      Ted Lemon (hereinafter referred to as the author)
  4  *
  5  * Redistribution and use in source and binary forms, with or without
  6  * modification, are permitted provided that the following conditions
  7  * are met:
  8  * 1. Redistributions of source code must retain the above copyright
  9  *    notice, this list of conditions and the following disclaimer.
 10  * 2. Redistributions in binary form must reproduce the above copyright
 11  *    notice, this list of conditions and the following disclaimer in the
 12  *    documentation and/or other materials provided with the distribution.
 13  * 3. The name of the author may not be used to endorse or promote products
 14  *    derived from this software without specific prior written permission.
 15  *
 16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
 17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
 20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 26  * SUCH DAMAGE.
 27  */
 28 
 29 /* elf2ecoff.c
 30 
 31    This program converts an elf executable to an ECOFF executable.
 32    No symbol table is retained.   This is useful primarily in building
 33    net-bootable kernels for machines (e.g., DECstation and Alpha) which
 34    only support the ECOFF object file format. */
 35 
 36 #include <stdio.h>
 37 #include <string.h>
 38 #include <errno.h>
 39 #include <sys/types.h>
 40 #include <fcntl.h>
 41 #include <unistd.h>
 42 #include <elf.h>
 43 #include <limits.h>
 44 #include <netinet/in.h>
 45 #include <stdlib.h>
 46 #include <stdint.h>
 47 #include <inttypes.h>
 48 
 49 #include "ecoff.h"
 50 
 51 /*
 52  * Some extra ELF definitions
 53  */
 54 #define PT_MIPS_REGINFO         0x70000000      /* Register usage information */
 55 #define PT_MIPS_ABIFLAGS        0x70000003      /* Records ABI related flags  */
 56 
 57 /* -------------------------------------------------------------------- */
 58 
 59 struct sect {
 60         uint32_t vaddr;
 61         uint32_t len;
 62 };
 63 
 64 int *symTypeTable;
 65 int must_convert_endian;
 66 int format_bigendian;
 67 
 68 static void copy(int out, int in, off_t offset, off_t size)
 69 {
 70         char ibuf[4096];
 71         int remaining, cur, count;
 72 
 73         /* Go to the start of the ELF symbol table... */
 74         if (lseek(in, offset, SEEK_SET) < 0) {
 75                 perror("copy: lseek");
 76                 exit(1);
 77         }
 78 
 79         remaining = size;
 80         while (remaining) {
 81                 cur = remaining;
 82                 if (cur > sizeof ibuf)
 83                         cur = sizeof ibuf;
 84                 remaining -= cur;
 85                 if ((count = read(in, ibuf, cur)) != cur) {
 86                         fprintf(stderr, "copy: read: %s\n",
 87                                 count ? strerror(errno) :
 88                                 "premature end of file");
 89                         exit(1);
 90                 }
 91                 if ((count = write(out, ibuf, cur)) != cur) {
 92                         perror("copy: write");
 93                         exit(1);
 94                 }
 95         }
 96 }
 97 
 98 /*
 99  * Combine two segments, which must be contiguous.   If pad is true, it's
100  * okay for there to be padding between.
101  */
102 static void combine(struct sect *base, struct sect *new, int pad)
103 {
104         if (!base->len)
105                 *base = *new;
106         else if (new->len) {
107                 if (base->vaddr + base->len != new->vaddr) {
108                         if (pad)
109                                 base->len = new->vaddr - base->vaddr;
110                         else {
111                                 fprintf(stderr,
112                                         "Non-contiguous data can't be converted.\n");
113                                 exit(1);
114                         }
115                 }
116                 base->len += new->len;
117         }
118 }
119 
120 static int phcmp(const void *v1, const void *v2)
121 {
122         const Elf32_Phdr *h1 = v1;
123         const Elf32_Phdr *h2 = v2;
124 
125         if (h1->p_vaddr > h2->p_vaddr)
126                 return 1;
127         else if (h1->p_vaddr < h2->p_vaddr)
128                 return -1;
129         else
130                 return 0;
131 }
132 
133 static char *saveRead(int file, off_t offset, off_t len, char *name)
134 {
135         char *tmp;
136         int count;
137         off_t off;
138         if ((off = lseek(file, offset, SEEK_SET)) < 0) {
139                 fprintf(stderr, "%s: fseek: %s\n", name, strerror(errno));
140                 exit(1);
141         }
142         if (!(tmp = (char *) malloc(len))) {
143                 fprintf(stderr, "%s: Can't allocate %ld bytes.\n", name,
144                         len);
145                 exit(1);
146         }
147         count = read(file, tmp, len);
148         if (count != len) {
149                 fprintf(stderr, "%s: read: %s.\n",
150                         name,
151                         count ? strerror(errno) : "End of file reached");
152                 exit(1);
153         }
154         return tmp;
155 }
156 
157 #define swab16(x) \
158         ((uint16_t)( \
159                 (((uint16_t)(x) & (uint16_t)0x00ffU) << 8) | \
160                 (((uint16_t)(x) & (uint16_t)0xff00U) >> 8) ))
161 
162 #define swab32(x) \
163         ((unsigned int)( \
164                 (((uint32_t)(x) & (uint32_t)0x000000ffUL) << 24) | \
165                 (((uint32_t)(x) & (uint32_t)0x0000ff00UL) <<  8) | \
166                 (((uint32_t)(x) & (uint32_t)0x00ff0000UL) >>  8) | \
167                 (((uint32_t)(x) & (uint32_t)0xff000000UL) >> 24) ))
168 
169 static void convert_elf_hdr(Elf32_Ehdr * e)
170 {
171         e->e_type = swab16(e->e_type);
172         e->e_machine = swab16(e->e_machine);
173         e->e_version = swab32(e->e_version);
174         e->e_entry = swab32(e->e_entry);
175         e->e_phoff = swab32(e->e_phoff);
176         e->e_shoff = swab32(e->e_shoff);
177         e->e_flags = swab32(e->e_flags);
178         e->e_ehsize = swab16(e->e_ehsize);
179         e->e_phentsize = swab16(e->e_phentsize);
180         e->e_phnum = swab16(e->e_phnum);
181         e->e_shentsize = swab16(e->e_shentsize);
182         e->e_shnum = swab16(e->e_shnum);
183         e->e_shstrndx = swab16(e->e_shstrndx);
184 }
185 
186 static void convert_elf_phdrs(Elf32_Phdr * p, int num)
187 {
188         int i;
189 
190         for (i = 0; i < num; i++, p++) {
191                 p->p_type = swab32(p->p_type);
192                 p->p_offset = swab32(p->p_offset);
193                 p->p_vaddr = swab32(p->p_vaddr);
194                 p->p_paddr = swab32(p->p_paddr);
195                 p->p_filesz = swab32(p->p_filesz);
196                 p->p_memsz = swab32(p->p_memsz);
197                 p->p_flags = swab32(p->p_flags);
198                 p->p_align = swab32(p->p_align);
199         }
200 
201 }
202 
203 static void convert_elf_shdrs(Elf32_Shdr * s, int num)
204 {
205         int i;
206 
207         for (i = 0; i < num; i++, s++) {
208                 s->sh_name = swab32(s->sh_name);
209                 s->sh_type = swab32(s->sh_type);
210                 s->sh_flags = swab32(s->sh_flags);
211                 s->sh_addr = swab32(s->sh_addr);
212                 s->sh_offset = swab32(s->sh_offset);
213                 s->sh_size = swab32(s->sh_size);
214                 s->sh_link = swab32(s->sh_link);
215                 s->sh_info = swab32(s->sh_info);
216                 s->sh_addralign = swab32(s->sh_addralign);
217                 s->sh_entsize = swab32(s->sh_entsize);
218         }
219 }
220 
221 static void convert_ecoff_filehdr(struct filehdr *f)
222 {
223         f->f_magic = swab16(f->f_magic);
224         f->f_nscns = swab16(f->f_nscns);
225         f->f_timdat = swab32(f->f_timdat);
226         f->f_symptr = swab32(f->f_symptr);
227         f->f_nsyms = swab32(f->f_nsyms);
228         f->f_opthdr = swab16(f->f_opthdr);
229         f->f_flags = swab16(f->f_flags);
230 }
231 
232 static void convert_ecoff_aouthdr(struct aouthdr *a)
233 {
234         a->magic = swab16(a->magic);
235         a->vstamp = swab16(a->vstamp);
236         a->tsize = swab32(a->tsize);
237         a->dsize = swab32(a->dsize);
238         a->bsize = swab32(a->bsize);
239         a->entry = swab32(a->entry);
240         a->text_start = swab32(a->text_start);
241         a->data_start = swab32(a->data_start);
242         a->bss_start = swab32(a->bss_start);
243         a->gprmask = swab32(a->gprmask);
244         a->cprmask[0] = swab32(a->cprmask[0]);
245         a->cprmask[1] = swab32(a->cprmask[1]);
246         a->cprmask[2] = swab32(a->cprmask[2]);
247         a->cprmask[3] = swab32(a->cprmask[3]);
248         a->gp_value = swab32(a->gp_value);
249 }
250 
251 static void convert_ecoff_esecs(struct scnhdr *s, int num)
252 {
253         int i;
254 
255         for (i = 0; i < num; i++, s++) {
256                 s->s_paddr = swab32(s->s_paddr);
257                 s->s_vaddr = swab32(s->s_vaddr);
258                 s->s_size = swab32(s->s_size);
259                 s->s_scnptr = swab32(s->s_scnptr);
260                 s->s_relptr = swab32(s->s_relptr);
261                 s->s_lnnoptr = swab32(s->s_lnnoptr);
262                 s->s_nreloc = swab16(s->s_nreloc);
263                 s->s_nlnno = swab16(s->s_nlnno);
264                 s->s_flags = swab32(s->s_flags);
265         }
266 }
267 
268 int main(int argc, char *argv[])
269 {
270         Elf32_Ehdr ex;
271         Elf32_Phdr *ph;
272         Elf32_Shdr *sh;
273         int i, pad;
274         struct sect text, data, bss;
275         struct filehdr efh;
276         struct aouthdr eah;
277         struct scnhdr esecs[6];
278         int infile, outfile;
279         uint32_t cur_vma = UINT32_MAX;
280         int addflag = 0;
281         int nosecs;
282 
283         text.len = data.len = bss.len = 0;
284         text.vaddr = data.vaddr = bss.vaddr = 0;
285 
286         /* Check args... */
287         if (argc < 3 || argc > 4) {
288               usage:
289                 fprintf(stderr,
290                         "usage: elf2ecoff <elf executable> <ecoff executable> [-a]\n");
291                 exit(1);
292         }
293         if (argc == 4) {
294                 if (strcmp(argv[3], "-a"))
295                         goto usage;
296                 addflag = 1;
297         }
298 
299         /* Try the input file... */
300         if ((infile = open(argv[1], O_RDONLY)) < 0) {
301                 fprintf(stderr, "Can't open %s for read: %s\n",
302                         argv[1], strerror(errno));
303                 exit(1);
304         }
305 
306         /* Read the header, which is at the beginning of the file... */
307         i = read(infile, &ex, sizeof ex);
308         if (i != sizeof ex) {
309                 fprintf(stderr, "ex: %s: %s.\n",
310                         argv[1],
311                         i ? strerror(errno) : "End of file reached");
312                 exit(1);
313         }
314 
315         if (ex.e_ident[EI_DATA] == ELFDATA2MSB)
316                 format_bigendian = 1;
317 
318         if (ntohs(0xaa55) == 0xaa55) {
319                 if (!format_bigendian)
320                         must_convert_endian = 1;
321         } else {
322                 if (format_bigendian)
323                         must_convert_endian = 1;
324         }
325         if (must_convert_endian)
326                 convert_elf_hdr(&ex);
327 
328         /* Read the program headers... */
329         ph = (Elf32_Phdr *) saveRead(infile, ex.e_phoff,
330                                      ex.e_phnum * sizeof(Elf32_Phdr),
331                                      "ph");
332         if (must_convert_endian)
333                 convert_elf_phdrs(ph, ex.e_phnum);
334         /* Read the section headers... */
335         sh = (Elf32_Shdr *) saveRead(infile, ex.e_shoff,
336                                      ex.e_shnum * sizeof(Elf32_Shdr),
337                                      "sh");
338         if (must_convert_endian)
339                 convert_elf_shdrs(sh, ex.e_shnum);
340 
341         /* Figure out if we can cram the program header into an ECOFF
342            header...  Basically, we can't handle anything but loadable
343            segments, but we can ignore some kinds of segments.  We can't
344            handle holes in the address space.  Segments may be out of order,
345            so we sort them first. */
346 
347         qsort(ph, ex.e_phnum, sizeof(Elf32_Phdr), phcmp);
348 
349         for (i = 0; i < ex.e_phnum; i++) {
350                 /* Section types we can ignore... */
351                 switch (ph[i].p_type) {
352                 case PT_NULL:
353                 case PT_NOTE:
354                 case PT_PHDR:
355                 case PT_MIPS_REGINFO:
356                 case PT_MIPS_ABIFLAGS:
357                         continue;
358 
359                 case PT_LOAD:
360                         /* Writable (data) segment? */
361                         if (ph[i].p_flags & PF_W) {
362                                 struct sect ndata, nbss;
363 
364                                 ndata.vaddr = ph[i].p_vaddr;
365                                 ndata.len = ph[i].p_filesz;
366                                 nbss.vaddr = ph[i].p_vaddr + ph[i].p_filesz;
367                                 nbss.len = ph[i].p_memsz - ph[i].p_filesz;
368 
369                                 combine(&data, &ndata, 0);
370                                 combine(&bss, &nbss, 1);
371                         } else {
372                                 struct sect ntxt;
373 
374                                 ntxt.vaddr = ph[i].p_vaddr;
375                                 ntxt.len = ph[i].p_filesz;
376 
377                                 combine(&text, &ntxt, 0);
378                         }
379                         /* Remember the lowest segment start address. */
380                         if (ph[i].p_vaddr < cur_vma)
381                                 cur_vma = ph[i].p_vaddr;
382                         break;
383 
384                 default:
385                         /* Section types we can't handle... */
386                         fprintf(stderr,
387                                 "Program header %d type %d can't be converted.\n",
388                                 ex.e_phnum, ph[i].p_type);
389                         exit(1);
390                 }
391         }
392 
393         /* Sections must be in order to be converted... */
394         if (text.vaddr > data.vaddr || data.vaddr > bss.vaddr ||
395             text.vaddr + text.len > data.vaddr
396             || data.vaddr + data.len > bss.vaddr) {
397                 fprintf(stderr,
398                         "Sections ordering prevents a.out conversion.\n");
399                 exit(1);
400         }
401 
402         /* If there's a data section but no text section, then the loader
403            combined everything into one section.   That needs to be the
404            text section, so just make the data section zero length following
405            text. */
406         if (data.len && !text.len) {
407                 text = data;
408                 data.vaddr = text.vaddr + text.len;
409                 data.len = 0;
410         }
411 
412         /* If there is a gap between text and data, we'll fill it when we copy
413            the data, so update the length of the text segment as represented in
414            a.out to reflect that, since a.out doesn't allow gaps in the program
415            address space. */
416         if (text.vaddr + text.len < data.vaddr)
417                 text.len = data.vaddr - text.vaddr;
418 
419         /* We now have enough information to cons up an a.out header... */
420         eah.magic = OMAGIC;
421         eah.vstamp = 200;
422         eah.tsize = text.len;
423         eah.dsize = data.len;
424         eah.bsize = bss.len;
425         eah.entry = ex.e_entry;
426         eah.text_start = text.vaddr;
427         eah.data_start = data.vaddr;
428         eah.bss_start = bss.vaddr;
429         eah.gprmask = 0xf3fffffe;
430         memset(&eah.cprmask, '\0', sizeof eah.cprmask);
431         eah.gp_value = 0;       /* unused. */
432 
433         if (format_bigendian)
434                 efh.f_magic = MIPSEBMAGIC;
435         else
436                 efh.f_magic = MIPSELMAGIC;
437         if (addflag)
438                 nosecs = 6;
439         else
440                 nosecs = 3;
441         efh.f_nscns = nosecs;
442         efh.f_timdat = 0;       /* bogus */
443         efh.f_symptr = 0;
444         efh.f_nsyms = 0;
445         efh.f_opthdr = sizeof eah;
446         efh.f_flags = 0x100f;   /* Stripped, not sharable. */
447 
448         memset(esecs, 0, sizeof esecs);
449         strcpy(esecs[0].s_name, ".text");
450         strcpy(esecs[1].s_name, ".data");
451         strcpy(esecs[2].s_name, ".bss");
452         if (addflag) {
453                 strcpy(esecs[3].s_name, ".rdata");
454                 strcpy(esecs[4].s_name, ".sdata");
455                 strcpy(esecs[5].s_name, ".sbss");
456         }
457         esecs[0].s_paddr = esecs[0].s_vaddr = eah.text_start;
458         esecs[1].s_paddr = esecs[1].s_vaddr = eah.data_start;
459         esecs[2].s_paddr = esecs[2].s_vaddr = eah.bss_start;
460         if (addflag) {
461                 esecs[3].s_paddr = esecs[3].s_vaddr = 0;
462                 esecs[4].s_paddr = esecs[4].s_vaddr = 0;
463                 esecs[5].s_paddr = esecs[5].s_vaddr = 0;
464         }
465         esecs[0].s_size = eah.tsize;
466         esecs[1].s_size = eah.dsize;
467         esecs[2].s_size = eah.bsize;
468         if (addflag) {
469                 esecs[3].s_size = 0;
470                 esecs[4].s_size = 0;
471                 esecs[5].s_size = 0;
472         }
473         esecs[0].s_scnptr = N_TXTOFF(efh, eah);
474         esecs[1].s_scnptr = N_DATOFF(efh, eah);
475 #define ECOFF_SEGMENT_ALIGNMENT(a) 0x10
476 #define ECOFF_ROUND(s, a) (((s)+(a)-1)&~((a)-1))
477         esecs[2].s_scnptr = esecs[1].s_scnptr +
478             ECOFF_ROUND(esecs[1].s_size, ECOFF_SEGMENT_ALIGNMENT(&eah));
479         if (addflag) {
480                 esecs[3].s_scnptr = 0;
481                 esecs[4].s_scnptr = 0;
482                 esecs[5].s_scnptr = 0;
483         }
484         esecs[0].s_relptr = esecs[1].s_relptr = esecs[2].s_relptr = 0;
485         esecs[0].s_lnnoptr = esecs[1].s_lnnoptr = esecs[2].s_lnnoptr = 0;
486         esecs[0].s_nreloc = esecs[1].s_nreloc = esecs[2].s_nreloc = 0;
487         esecs[0].s_nlnno = esecs[1].s_nlnno = esecs[2].s_nlnno = 0;
488         if (addflag) {
489                 esecs[3].s_relptr = esecs[4].s_relptr
490                     = esecs[5].s_relptr = 0;
491                 esecs[3].s_lnnoptr = esecs[4].s_lnnoptr
492                     = esecs[5].s_lnnoptr = 0;
493                 esecs[3].s_nreloc = esecs[4].s_nreloc = esecs[5].s_nreloc =
494                     0;
495                 esecs[3].s_nlnno = esecs[4].s_nlnno = esecs[5].s_nlnno = 0;
496         }
497         esecs[0].s_flags = 0x20;
498         esecs[1].s_flags = 0x40;
499         esecs[2].s_flags = 0x82;
500         if (addflag) {
501                 esecs[3].s_flags = 0x100;
502                 esecs[4].s_flags = 0x200;
503                 esecs[5].s_flags = 0x400;
504         }
505 
506         /* Make the output file... */
507         if ((outfile = open(argv[2], O_WRONLY | O_CREAT, 0777)) < 0) {
508                 fprintf(stderr, "Unable to create %s: %s\n", argv[2],
509                         strerror(errno));
510                 exit(1);
511         }
512 
513         if (must_convert_endian)
514                 convert_ecoff_filehdr(&efh);
515         /* Write the headers... */
516         i = write(outfile, &efh, sizeof efh);
517         if (i != sizeof efh) {
518                 perror("efh: write");
519                 exit(1);
520 
521                 for (i = 0; i < nosecs; i++) {
522                         printf
523                             ("Section %d: %s phys %"PRIx32"  size %"PRIx32"\t file offset %"PRIx32"\n",
524                              i, esecs[i].s_name, esecs[i].s_paddr,
525                              esecs[i].s_size, esecs[i].s_scnptr);
526                 }
527         }
528         fprintf(stderr, "wrote %d byte file header.\n", i);
529 
530         if (must_convert_endian)
531                 convert_ecoff_aouthdr(&eah);
532         i = write(outfile, &eah, sizeof eah);
533         if (i != sizeof eah) {
534                 perror("eah: write");
535                 exit(1);
536         }
537         fprintf(stderr, "wrote %d byte a.out header.\n", i);
538 
539         if (must_convert_endian)
540                 convert_ecoff_esecs(&esecs[0], nosecs);
541         i = write(outfile, &esecs, nosecs * sizeof(struct scnhdr));
542         if (i != nosecs * sizeof(struct scnhdr)) {
543                 perror("esecs: write");
544                 exit(1);
545         }
546         fprintf(stderr, "wrote %d bytes of section headers.\n", i);
547 
548         pad = (sizeof(efh) + sizeof(eah) + nosecs * sizeof(struct scnhdr)) & 15;
549         if (pad) {
550                 pad = 16 - pad;
551                 i = write(outfile, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0", pad);
552                 if (i < 0) {
553                         perror("ipad: write");
554                         exit(1);
555                 }
556                 fprintf(stderr, "wrote %d byte pad.\n", i);
557         }
558 
559         /*
560          * Copy the loadable sections.   Zero-fill any gaps less than 64k;
561          * complain about any zero-filling, and die if we're asked to zero-fill
562          * more than 64k.
563          */
564         for (i = 0; i < ex.e_phnum; i++) {
565                 /* Unprocessable sections were handled above, so just verify that
566                    the section can be loaded before copying. */
567                 if (ph[i].p_type == PT_LOAD && ph[i].p_filesz) {
568                         if (cur_vma != ph[i].p_vaddr) {
569                                 uint32_t gap = ph[i].p_vaddr - cur_vma;
570                                 char obuf[1024];
571                                 if (gap > 65536) {
572                                         fprintf(stderr,
573                                                 "Intersegment gap (%"PRId32" bytes) too large.\n",
574                                                 gap);
575                                         exit(1);
576                                 }
577                                 fprintf(stderr,
578                                         "Warning: %d byte intersegment gap.\n",
579                                         gap);
580                                 memset(obuf, 0, sizeof obuf);
581                                 while (gap) {
582                                         int count =
583                                             write(outfile, obuf,
584                                                   (gap >
585                                                    sizeof obuf ? sizeof
586                                                    obuf : gap));
587                                         if (count < 0) {
588                                                 fprintf(stderr,
589                                                         "Error writing gap: %s\n",
590                                                         strerror(errno));
591                                                 exit(1);
592                                         }
593                                         gap -= count;
594                                 }
595                         }
596                         fprintf(stderr, "writing %d bytes...\n",
597                                 ph[i].p_filesz);
598                         copy(outfile, infile, ph[i].p_offset,
599                              ph[i].p_filesz);
600                         cur_vma = ph[i].p_vaddr + ph[i].p_filesz;
601                 }
602         }
603 
604         /*
605          * Write a page of padding for boot PROMS that read entire pages.
606          * Without this, they may attempt to read past the end of the
607          * data section, incur an error, and refuse to boot.
608          */
609         {
610                 char obuf[4096];
611                 memset(obuf, 0, sizeof obuf);
612                 if (write(outfile, obuf, sizeof(obuf)) != sizeof(obuf)) {
613                         fprintf(stderr, "Error writing PROM padding: %s\n",
614                                 strerror(errno));
615                         exit(1);
616                 }
617         }
618 
619         /* Looks like we won... */
620         exit(0);
621 }
622 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp