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

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

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

~ [ 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