664 lines
17 KiB
C
664 lines
17 KiB
C
|
#include <stdarg.h>
|
||
|
|
#include <errno.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <stdint.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <sys/types.h>
|
||
|
|
#include <sys/stat.h>
|
||
|
|
#include <fcntl.h>
|
||
|
|
#include <unistd.h>
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <getopt.h>
|
||
|
|
#ifdef HAVE_ZLIB_H
|
||
|
|
#include <zlib.h>
|
||
|
|
#endif
|
||
|
|
#include "elf.h"
|
||
|
|
#include "elf_boot.h"
|
||
|
|
#include "mkelfImage.h"
|
||
|
|
|
||
|
|
static struct file_type file_type[] = {
|
||
|
|
{ "linux-i386", linux_i386_probe, linux_i386_mkelf, linux_i386_usage },
|
||
|
|
{ "bzImage-i386", bzImage_i386_probe, linux_i386_mkelf, linux_i386_usage },
|
||
|
|
{ "vmlinux-i386", vmlinux_i386_probe, linux_i386_mkelf, linux_i386_usage },
|
||
|
|
{ "linux-ia64", linux_ia64_probe, linux_ia64_mkelf, linux_ia64_usage },
|
||
|
|
};
|
||
|
|
static const int file_types = sizeof(file_type)/sizeof(file_type[0]);
|
||
|
|
|
||
|
|
void die(char *fmt, ...)
|
||
|
|
{
|
||
|
|
va_list args;
|
||
|
|
va_start(args, fmt);
|
||
|
|
vfprintf(stderr, fmt, args);
|
||
|
|
va_end(args);
|
||
|
|
exit(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**************************************************************************
|
||
|
|
IPCHKSUM - Checksum IP Header
|
||
|
|
**************************************************************************/
|
||
|
|
uint16_t ipchksum(const void *data, unsigned long length)
|
||
|
|
{
|
||
|
|
unsigned long sum;
|
||
|
|
unsigned long i;
|
||
|
|
const uint8_t *ptr;
|
||
|
|
|
||
|
|
/* In the most straight forward way possible,
|
||
|
|
* compute an ip style checksum.
|
||
|
|
*/
|
||
|
|
sum = 0;
|
||
|
|
ptr = data;
|
||
|
|
for(i = 0; i < length; i++) {
|
||
|
|
unsigned long value;
|
||
|
|
value = ptr[i];
|
||
|
|
if (i & 1) {
|
||
|
|
value <<= 8;
|
||
|
|
}
|
||
|
|
/* Add the new value */
|
||
|
|
sum += value;
|
||
|
|
/* Wrap around the carry */
|
||
|
|
if (sum > 0xFFFF) {
|
||
|
|
sum = (sum + (sum >> 16)) & 0xFFFF;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return (~cpu_to_le16(sum)) & 0xFFFF;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint16_t add_ipchksums(unsigned long offset, uint16_t sum, uint16_t new)
|
||
|
|
{
|
||
|
|
unsigned long checksum;
|
||
|
|
sum = ~sum & 0xFFFF;
|
||
|
|
new = ~new & 0xFFFF;
|
||
|
|
if (offset & 1) {
|
||
|
|
/* byte swap the sum if it came from an odd offset
|
||
|
|
* since the computation is endian independant this
|
||
|
|
* works.
|
||
|
|
*/
|
||
|
|
new = bswap_16(new);
|
||
|
|
}
|
||
|
|
checksum = sum + new;
|
||
|
|
if (checksum > 0xFFFF) {
|
||
|
|
checksum -= 0xFFFF;
|
||
|
|
}
|
||
|
|
return (~checksum) & 0xFFFF;
|
||
|
|
}
|
||
|
|
|
||
|
|
void *xmalloc(size_t size, const char *name)
|
||
|
|
{
|
||
|
|
void *buf;
|
||
|
|
buf = malloc(size);
|
||
|
|
if (!buf) {
|
||
|
|
die("Cannot malloc %ld bytes to hold %s: %s\n",
|
||
|
|
size + 0UL, name, strerror(errno));
|
||
|
|
}
|
||
|
|
return buf;
|
||
|
|
}
|
||
|
|
|
||
|
|
void *xrealloc(void *ptr, size_t size, const char *name)
|
||
|
|
{
|
||
|
|
void *buf;
|
||
|
|
buf = realloc(ptr, size);
|
||
|
|
if (!buf) {
|
||
|
|
die("Cannot realloc %ld bytes to hold %s: %s\n",
|
||
|
|
size + 0UL, name, strerror(errno));
|
||
|
|
}
|
||
|
|
return buf;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
char *slurp_file(const char *filename, off_t *r_size)
|
||
|
|
{
|
||
|
|
int fd;
|
||
|
|
char *buf;
|
||
|
|
off_t size, progress;
|
||
|
|
ssize_t result;
|
||
|
|
struct stat stats;
|
||
|
|
|
||
|
|
|
||
|
|
if (!filename) {
|
||
|
|
*r_size = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
fd = open(filename, O_RDONLY);
|
||
|
|
if (fd < 0) {
|
||
|
|
die("Cannot open `%s': %s\n",
|
||
|
|
filename, strerror(errno));
|
||
|
|
}
|
||
|
|
result = fstat(fd, &stats);
|
||
|
|
if (result < 0) {
|
||
|
|
die("Cannot stat: %s: %s\n",
|
||
|
|
filename, strerror(errno));
|
||
|
|
}
|
||
|
|
size = stats.st_size;
|
||
|
|
*r_size = size;
|
||
|
|
buf = xmalloc(size, filename);
|
||
|
|
progress = 0;
|
||
|
|
while(progress < size) {
|
||
|
|
result = read(fd, buf + progress, size - progress);
|
||
|
|
if (result < 0) {
|
||
|
|
if ((errno == EINTR) || (errno == EAGAIN))
|
||
|
|
continue;
|
||
|
|
die("read on %s of %ld bytes failed: %s\n",
|
||
|
|
filename, (size - progress)+ 0UL, strerror(errno));
|
||
|
|
}
|
||
|
|
progress += result;
|
||
|
|
}
|
||
|
|
result = close(fd);
|
||
|
|
if (result < 0) {
|
||
|
|
die("Close of %s failed: %s\n",
|
||
|
|
filename, strerror(errno));
|
||
|
|
}
|
||
|
|
return buf;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if HAVE_ZLIB_H
|
||
|
|
char *slurp_decompress_file(const char *filename, off_t *r_size)
|
||
|
|
{
|
||
|
|
gzFile fp;
|
||
|
|
int errnum;
|
||
|
|
const char *msg;
|
||
|
|
char *buf;
|
||
|
|
off_t size, allocated;
|
||
|
|
ssize_t result;
|
||
|
|
|
||
|
|
if (!filename) {
|
||
|
|
*r_size = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
fp = gzopen(filename, "rb");
|
||
|
|
if (fp == 0) {
|
||
|
|
msg = gzerror(fp, &errnum);
|
||
|
|
if (errnum == Z_ERRNO) {
|
||
|
|
msg = strerror(errno);
|
||
|
|
}
|
||
|
|
die("Cannot open `%s': %s\n", filename, msg);
|
||
|
|
}
|
||
|
|
size = 0;
|
||
|
|
allocated = 65536;
|
||
|
|
buf = xmalloc(allocated, filename);
|
||
|
|
do {
|
||
|
|
if (size == allocated) {
|
||
|
|
allocated <<= 1;
|
||
|
|
buf = xrealloc(buf, allocated, filename);
|
||
|
|
}
|
||
|
|
result = gzread(fp, buf + size, allocated - size);
|
||
|
|
if (result < 0) {
|
||
|
|
if ((errno == EINTR) || (errno == EAGAIN))
|
||
|
|
continue;
|
||
|
|
|
||
|
|
msg = gzerror(fp, &errnum);
|
||
|
|
if (errnum == Z_ERRNO) {
|
||
|
|
msg = strerror(errno);
|
||
|
|
}
|
||
|
|
die ("read on %s of %ld bytes failed: %s\n",
|
||
|
|
filename, (allocated - size) + 0UL, msg);
|
||
|
|
}
|
||
|
|
size += result;
|
||
|
|
} while(result > 0);
|
||
|
|
result = gzclose(fp);
|
||
|
|
if (result != Z_OK) {
|
||
|
|
msg = gzerror(fp, &errnum);
|
||
|
|
if (errnum == Z_ERRNO) {
|
||
|
|
msg = strerror(errno);
|
||
|
|
}
|
||
|
|
die ("Close of %s failed: %s\n", filename, msg);
|
||
|
|
}
|
||
|
|
*r_size = size;
|
||
|
|
return buf;
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
char *slurp_decompress_file(const char *filename, off_t *r_size)
|
||
|
|
{
|
||
|
|
return slurp_file(filename, r_size);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
struct memelfphdr *add_program_headers(struct memelfheader *ehdr, int count)
|
||
|
|
{
|
||
|
|
struct memelfphdr *phdr;
|
||
|
|
int i;
|
||
|
|
ehdr->e_phnum = count;
|
||
|
|
ehdr->e_phdr = phdr = xmalloc(count *sizeof(*phdr), "Program headers");
|
||
|
|
/* Set the default values */
|
||
|
|
for(i = 0; i < count; i++) {
|
||
|
|
phdr[i].p_type = PT_LOAD;
|
||
|
|
phdr[i].p_flags = PF_R | PF_W | PF_X;
|
||
|
|
phdr[i].p_vaddr = 0;
|
||
|
|
phdr[i].p_paddr = 0;
|
||
|
|
phdr[i].p_filesz = 0;
|
||
|
|
phdr[i].p_memsz = 0;
|
||
|
|
phdr[i].p_data = 0;
|
||
|
|
}
|
||
|
|
return phdr;
|
||
|
|
}
|
||
|
|
|
||
|
|
struct memelfnote *add_notes(struct memelfheader *ehdr, int count)
|
||
|
|
{
|
||
|
|
struct memelfnote *notes;
|
||
|
|
ehdr->e_notenum = count;
|
||
|
|
ehdr->e_notes = notes = xmalloc(count *sizeof(*notes), "Notes");
|
||
|
|
memset(notes, 0, count *sizeof(*notes));
|
||
|
|
return notes;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int sizeof_notes(struct memelfnote *note, int notes)
|
||
|
|
{
|
||
|
|
int size;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
size = 0;
|
||
|
|
for(i = 0; i < notes; i++) {
|
||
|
|
size += sizeof(Elf_Nhdr);
|
||
|
|
size += roundup(strlen(note[i].n_name)+1, 4);
|
||
|
|
size += roundup(note[i].n_descsz, 4);
|
||
|
|
}
|
||
|
|
return size;
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint16_t cpu_to_elf16(struct memelfheader *ehdr, uint16_t val)
|
||
|
|
{
|
||
|
|
if (ehdr->ei_data == ELFDATA2LSB) {
|
||
|
|
return cpu_to_le16(val);
|
||
|
|
}
|
||
|
|
else if (ehdr->ei_data == ELFDATA2MSB) {
|
||
|
|
return cpu_to_be16(val);
|
||
|
|
}
|
||
|
|
die("Uknown elf layout in cpu_to_elf16");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint32_t cpu_to_elf32(struct memelfheader *ehdr, uint32_t val)
|
||
|
|
{
|
||
|
|
if (ehdr->ei_data == ELFDATA2LSB) {
|
||
|
|
return cpu_to_le32(val);
|
||
|
|
}
|
||
|
|
else if (ehdr->ei_data == ELFDATA2MSB) {
|
||
|
|
return cpu_to_be32(val);
|
||
|
|
}
|
||
|
|
die("Uknown elf layout in cpu_to_elf32");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint64_t cpu_to_elf64(struct memelfheader *ehdr, uint64_t val)
|
||
|
|
{
|
||
|
|
if (ehdr->ei_data == ELFDATA2LSB) {
|
||
|
|
return cpu_to_le64(val);
|
||
|
|
}
|
||
|
|
else if (ehdr->ei_data == ELFDATA2MSB) {
|
||
|
|
return cpu_to_be64(val);
|
||
|
|
}
|
||
|
|
die("Uknown elf layout in cpu_to_elf64");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void serialize_notes(char *buf, struct memelfheader *ehdr)
|
||
|
|
{
|
||
|
|
struct Elf_Nhdr hdr;
|
||
|
|
struct memelfnote *note;
|
||
|
|
int notes;
|
||
|
|
size_t size, offset;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
/* Clear the buffer */
|
||
|
|
note = ehdr->e_notes;
|
||
|
|
notes = ehdr->e_notenum;
|
||
|
|
size = sizeof_notes(note, notes);
|
||
|
|
memset(buf, 0, size);
|
||
|
|
|
||
|
|
/* Write the Elf Notes */
|
||
|
|
offset = 0;
|
||
|
|
for(i = 0; i < notes; i++) {
|
||
|
|
/* Compute the note header */
|
||
|
|
size_t n_namesz;
|
||
|
|
n_namesz = strlen(note[i].n_name) +1;
|
||
|
|
hdr.n_namesz = cpu_to_elf32(ehdr, n_namesz);
|
||
|
|
hdr.n_descsz = cpu_to_elf32(ehdr, note[i].n_descsz);
|
||
|
|
hdr.n_type = cpu_to_elf32(ehdr, note[i].n_type);
|
||
|
|
|
||
|
|
/* Copy the note into the buffer */
|
||
|
|
memcpy(buf + offset, &hdr, sizeof(hdr));
|
||
|
|
offset += sizeof(hdr);
|
||
|
|
memcpy(buf + offset, note[i].n_name, n_namesz);
|
||
|
|
offset += roundup(n_namesz, 4);
|
||
|
|
memcpy(buf + offset, note[i].n_desc, note[i].n_descsz);
|
||
|
|
offset += roundup(note[i].n_descsz, 4);
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
static void serialize_ehdr(char *buf, struct memelfheader *ehdr)
|
||
|
|
{
|
||
|
|
if (ehdr->ei_class == ELFCLASS32) {
|
||
|
|
Elf32_Ehdr *hdr = (Elf32_Ehdr *)buf;
|
||
|
|
hdr->e_ident[EI_MAG0] = ELFMAG0;
|
||
|
|
hdr->e_ident[EI_MAG1] = ELFMAG1;
|
||
|
|
hdr->e_ident[EI_MAG2] = ELFMAG2;
|
||
|
|
hdr->e_ident[EI_MAG3] = ELFMAG3;
|
||
|
|
hdr->e_ident[EI_CLASS] = ehdr->ei_class;
|
||
|
|
hdr->e_ident[EI_DATA] = ehdr->ei_data;
|
||
|
|
hdr->e_ident[EI_VERSION] = EV_CURRENT;
|
||
|
|
hdr->e_type = cpu_to_elf16(ehdr, ehdr->e_type);
|
||
|
|
hdr->e_machine = cpu_to_elf16(ehdr, ehdr->e_machine);
|
||
|
|
hdr->e_version = cpu_to_elf32(ehdr, EV_CURRENT);
|
||
|
|
hdr->e_entry = cpu_to_elf32(ehdr, ehdr->e_entry);
|
||
|
|
hdr->e_phoff = cpu_to_elf32(ehdr, sizeof(*hdr));
|
||
|
|
hdr->e_shoff = cpu_to_elf32(ehdr, 0);
|
||
|
|
hdr->e_flags = cpu_to_elf32(ehdr, ehdr->e_flags);
|
||
|
|
hdr->e_ehsize = cpu_to_elf16(ehdr, sizeof(*hdr));
|
||
|
|
hdr->e_phentsize = cpu_to_elf16(ehdr, sizeof(Elf32_Phdr));
|
||
|
|
hdr->e_phnum = cpu_to_elf16(ehdr, ehdr->e_phnum);
|
||
|
|
hdr->e_shentsize = cpu_to_elf16(ehdr, 0);
|
||
|
|
hdr->e_shnum = cpu_to_elf16(ehdr, 0);
|
||
|
|
hdr->e_shstrndx = cpu_to_elf16(ehdr, 0);
|
||
|
|
}
|
||
|
|
else if (ehdr->ei_class == ELFCLASS64) {
|
||
|
|
Elf64_Ehdr *hdr = (Elf64_Ehdr *)buf;
|
||
|
|
hdr->e_ident[EI_MAG0] = ELFMAG0;
|
||
|
|
hdr->e_ident[EI_MAG1] = ELFMAG1;
|
||
|
|
hdr->e_ident[EI_MAG2] = ELFMAG2;
|
||
|
|
hdr->e_ident[EI_MAG3] = ELFMAG3;
|
||
|
|
hdr->e_ident[EI_CLASS] = ehdr->ei_class;
|
||
|
|
hdr->e_ident[EI_DATA] = ehdr->ei_data;
|
||
|
|
hdr->e_ident[EI_VERSION] = EV_CURRENT;
|
||
|
|
hdr->e_type = cpu_to_elf16(ehdr, ehdr->e_type);
|
||
|
|
hdr->e_machine = cpu_to_elf16(ehdr, ehdr->e_machine);
|
||
|
|
hdr->e_version = cpu_to_elf32(ehdr, EV_CURRENT);
|
||
|
|
hdr->e_entry = cpu_to_elf64(ehdr, ehdr->e_entry);
|
||
|
|
hdr->e_phoff = cpu_to_elf64(ehdr, sizeof(*hdr));
|
||
|
|
hdr->e_shoff = cpu_to_elf64(ehdr, 0);
|
||
|
|
hdr->e_flags = cpu_to_elf32(ehdr, ehdr->e_flags);
|
||
|
|
hdr->e_ehsize = cpu_to_elf16(ehdr, sizeof(*hdr));
|
||
|
|
hdr->e_phentsize = cpu_to_elf16(ehdr, sizeof(Elf64_Phdr));
|
||
|
|
hdr->e_phnum = cpu_to_elf16(ehdr, ehdr->e_phnum);
|
||
|
|
hdr->e_shentsize = cpu_to_elf16(ehdr, 0);
|
||
|
|
hdr->e_shnum = cpu_to_elf16(ehdr, 0);
|
||
|
|
hdr->e_shstrndx = cpu_to_elf16(ehdr, 0);
|
||
|
|
}
|
||
|
|
else die("Uknown elf class: %x\n", ehdr->ei_class);
|
||
|
|
}
|
||
|
|
static void serialize_phdrs(char *buf, struct memelfheader *ehdr, size_t note_size)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
size_t offset, note_offset;
|
||
|
|
if (ehdr->ei_class == ELFCLASS32) {
|
||
|
|
Elf32_Phdr *phdr = (Elf32_Phdr *)buf;
|
||
|
|
note_offset =
|
||
|
|
sizeof(Elf32_Ehdr) + (sizeof(Elf32_Phdr)*ehdr->e_phnum);
|
||
|
|
offset = note_offset + note_size;
|
||
|
|
for(i = 0; i < ehdr->e_phnum; i++) {
|
||
|
|
struct memelfphdr *hdr = ehdr->e_phdr + i;
|
||
|
|
phdr[i].p_type = cpu_to_elf32(ehdr, hdr->p_type);
|
||
|
|
phdr[i].p_offset = cpu_to_elf32(ehdr, offset);
|
||
|
|
phdr[i].p_vaddr = cpu_to_elf32(ehdr, hdr->p_vaddr);
|
||
|
|
phdr[i].p_paddr = cpu_to_elf32(ehdr, hdr->p_paddr);
|
||
|
|
phdr[i].p_filesz = cpu_to_elf32(ehdr, hdr->p_filesz);
|
||
|
|
phdr[i].p_memsz = cpu_to_elf32(ehdr, hdr->p_memsz);
|
||
|
|
phdr[i].p_flags = cpu_to_elf32(ehdr, hdr->p_flags);
|
||
|
|
phdr[i].p_align = cpu_to_elf32(ehdr, 0);
|
||
|
|
if (phdr[i].p_type == PT_NOTE) {
|
||
|
|
phdr[i].p_filesz = cpu_to_elf32(ehdr, note_size);
|
||
|
|
phdr[i].p_memsz = cpu_to_elf32(ehdr, note_size);
|
||
|
|
phdr[i].p_offset = cpu_to_elf32(ehdr, note_offset);
|
||
|
|
} else {
|
||
|
|
offset += hdr->p_filesz;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (ehdr->ei_class == ELFCLASS64) {
|
||
|
|
Elf64_Phdr *phdr = (Elf64_Phdr *)buf;
|
||
|
|
note_offset =
|
||
|
|
sizeof(Elf64_Ehdr) + (sizeof(Elf64_Phdr)*ehdr->e_phnum);
|
||
|
|
offset = note_offset + note_size;
|
||
|
|
for(i = 0; i < ehdr->e_phnum; i++) {
|
||
|
|
struct memelfphdr *hdr = ehdr->e_phdr + i;
|
||
|
|
phdr[i].p_type = cpu_to_elf32(ehdr, hdr->p_type);
|
||
|
|
phdr[i].p_flags = cpu_to_elf32(ehdr, hdr->p_flags);
|
||
|
|
phdr[i].p_offset = cpu_to_elf64(ehdr, offset);
|
||
|
|
phdr[i].p_vaddr = cpu_to_elf64(ehdr, hdr->p_vaddr);
|
||
|
|
phdr[i].p_paddr = cpu_to_elf64(ehdr, hdr->p_paddr);
|
||
|
|
phdr[i].p_filesz = cpu_to_elf64(ehdr, hdr->p_filesz);
|
||
|
|
phdr[i].p_memsz = cpu_to_elf64(ehdr, hdr->p_memsz);
|
||
|
|
phdr[i].p_align = cpu_to_elf64(ehdr, 0);
|
||
|
|
if (phdr[i].p_type == PT_NOTE) {
|
||
|
|
phdr[i].p_filesz = cpu_to_elf64(ehdr, note_size);
|
||
|
|
phdr[i].p_memsz = cpu_to_elf64(ehdr, note_size);
|
||
|
|
phdr[i].p_offset = cpu_to_elf64(ehdr, note_offset);
|
||
|
|
} else {
|
||
|
|
offset += hdr->p_filesz;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
die("Unknwon elf class: %x\n", ehdr->ei_class);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void write_buf(int fd, char *buf, size_t size)
|
||
|
|
{
|
||
|
|
size_t progress = 0;
|
||
|
|
ssize_t result;
|
||
|
|
while(progress < size) {
|
||
|
|
result = write(fd, buf + progress, size - progress);
|
||
|
|
if (result < 0) {
|
||
|
|
if ((errno == EAGAIN) || (errno == EINTR)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
die ("write of %ld bytes failed: %s\n",
|
||
|
|
size - progress, strerror(errno));
|
||
|
|
}
|
||
|
|
progress += result;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
static void write_elf(struct memelfheader *ehdr, char *output)
|
||
|
|
{
|
||
|
|
size_t ehdr_size;
|
||
|
|
size_t phdr_size;
|
||
|
|
size_t note_size;
|
||
|
|
size_t size;
|
||
|
|
uint16_t checksum;
|
||
|
|
size_t bytes;
|
||
|
|
char *buf;
|
||
|
|
int result, fd;
|
||
|
|
int i;
|
||
|
|
/* Prep for adding the checksum */
|
||
|
|
for(i = 0; i < ehdr->e_notenum; i++) {
|
||
|
|
if ((memcmp(ehdr->e_notes[i].n_name, "ELFBoot", 8) == 0) &&
|
||
|
|
(ehdr->e_notes[i].n_type == EIN_PROGRAM_CHECKSUM)) {
|
||
|
|
ehdr->e_notes[i].n_desc = &checksum;
|
||
|
|
ehdr->e_notes[i].n_descsz = 2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/* Compute the sizes */
|
||
|
|
ehdr_size = 0;
|
||
|
|
phdr_size = 0;
|
||
|
|
note_size = 0;
|
||
|
|
if (ehdr->e_notenum) {
|
||
|
|
note_size = sizeof_notes(ehdr->e_notes, ehdr->e_notenum);
|
||
|
|
}
|
||
|
|
if (ehdr->ei_class == ELFCLASS32) {
|
||
|
|
ehdr_size = sizeof(Elf32_Ehdr);
|
||
|
|
phdr_size = sizeof(Elf32_Phdr) * ehdr->e_phnum;
|
||
|
|
}
|
||
|
|
else if (ehdr->ei_class == ELFCLASS64) {
|
||
|
|
ehdr_size = sizeof(Elf64_Ehdr);
|
||
|
|
phdr_size = sizeof(Elf64_Phdr) * ehdr->e_phnum;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
die("Unknown elf class: %x\n", ehdr->ei_class);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Allocate a buffer to temporarily hold the serialized forms */
|
||
|
|
size = ehdr_size + phdr_size + note_size;
|
||
|
|
buf = xmalloc(size, "Elf Headers");
|
||
|
|
memset(buf, 0, size);
|
||
|
|
serialize_ehdr(buf, ehdr);
|
||
|
|
serialize_phdrs(buf + ehdr_size, ehdr, note_size);
|
||
|
|
|
||
|
|
/* Compute the checksum... */
|
||
|
|
checksum = ipchksum(buf, ehdr_size + phdr_size);
|
||
|
|
bytes = ehdr_size + phdr_size;
|
||
|
|
for(i = 0; i < ehdr->e_phnum; i++) {
|
||
|
|
checksum = add_ipchksums(bytes, checksum,
|
||
|
|
ipchksum(ehdr->e_phdr[i].p_data, ehdr->e_phdr[i].p_filesz));
|
||
|
|
bytes += ehdr->e_phdr[i].p_memsz;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Compute the final form of the notes */
|
||
|
|
serialize_notes(buf + ehdr_size + phdr_size, ehdr);
|
||
|
|
|
||
|
|
/* Now write the elf image */
|
||
|
|
fd = open(output, O_WRONLY | O_CREAT | O_EXCL, S_IRUSR | S_IRGRP | S_IROTH);
|
||
|
|
if (fd < 0) {
|
||
|
|
die("Cannot open ``%s'':%s\n",
|
||
|
|
output, strerror(errno));
|
||
|
|
}
|
||
|
|
write_buf(fd, buf, size);
|
||
|
|
for(i = 0; i < ehdr->e_phnum; i++) {
|
||
|
|
write_buf(fd, ehdr->e_phdr[i].p_data, ehdr->e_phdr[i].p_filesz);
|
||
|
|
}
|
||
|
|
result = close(fd);
|
||
|
|
if (result < 0) {
|
||
|
|
die("Close on %s failed: %s\n",
|
||
|
|
output, strerror(errno));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void version(void)
|
||
|
|
{
|
||
|
|
printf("mkelfImage " VERSION " released " RELEASE_DATE "\n");
|
||
|
|
}
|
||
|
|
void usage(void)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
version();
|
||
|
|
printf(
|
||
|
|
"Usage: mkelfImage [OPTION]... <kernel> <elf_kernel>\n"
|
||
|
|
"Build an ELF bootable kernel image from a normal kernel image\n"
|
||
|
|
"\n"
|
||
|
|
" -h, --help Print this help.\n"
|
||
|
|
" -v, --version Print the version of kexec.\n"
|
||
|
|
" --kernel=<filename> Set the kernel to <filename>\n"
|
||
|
|
" --output=<filename> Output to <filename>\n"
|
||
|
|
" -t, --type=TYPE Specify the new kernel is of <type>.\n"
|
||
|
|
"\n"
|
||
|
|
"Supported kernel types: \n"
|
||
|
|
);
|
||
|
|
for(i = 0; i < file_types; i++) {
|
||
|
|
printf("%s\n", file_type[i].name);
|
||
|
|
file_type[i].usage();
|
||
|
|
}
|
||
|
|
printf("\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
void error(char *fmt, ...)
|
||
|
|
{
|
||
|
|
va_list args;
|
||
|
|
va_start(args, fmt);
|
||
|
|
vfprintf(stderr, fmt, args);
|
||
|
|
va_end(args);
|
||
|
|
usage();
|
||
|
|
exit(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
int main(int argc, char **argv)
|
||
|
|
{
|
||
|
|
int opt;
|
||
|
|
int fileind;
|
||
|
|
char *type, *kernel, *output;
|
||
|
|
off_t kernel_size;
|
||
|
|
char *kernel_buf;
|
||
|
|
int result;
|
||
|
|
int i;
|
||
|
|
struct memelfheader hdr;
|
||
|
|
|
||
|
|
static const struct option options[] = {
|
||
|
|
MKELF_OPTIONS
|
||
|
|
{ 0, 0, 0, 0 },
|
||
|
|
};
|
||
|
|
static const char short_options[] = MKELF_OPT_STR;
|
||
|
|
|
||
|
|
memset(&hdr, 0, sizeof(hdr));
|
||
|
|
kernel = 0;
|
||
|
|
output = 0;
|
||
|
|
|
||
|
|
/* Get the default type from the program name */
|
||
|
|
type = strrchr(argv[0], '/');
|
||
|
|
if (!type) type = argv[0];
|
||
|
|
if (memcmp(type, "mkelf-", 6) == 0) {
|
||
|
|
type = type + 6;
|
||
|
|
} else {
|
||
|
|
type = 0;
|
||
|
|
}
|
||
|
|
opterr = 0; /* Don't complain about unrecognized options here */
|
||
|
|
while ((opt = getopt_long(argc, argv, short_options, options, 0)) != -1) {
|
||
|
|
switch(opt) {
|
||
|
|
case OPT_HELP:
|
||
|
|
usage();
|
||
|
|
return 0;
|
||
|
|
case OPT_VERSION:
|
||
|
|
version();
|
||
|
|
return 0;
|
||
|
|
case OPT_KERNEL:
|
||
|
|
kernel = optarg;
|
||
|
|
break;
|
||
|
|
case OPT_OUTPUT:
|
||
|
|
output = optarg;
|
||
|
|
break;
|
||
|
|
case OPT_TYPE:
|
||
|
|
type = optarg;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
fileind = optind;
|
||
|
|
|
||
|
|
/* Reset getopt for the next pass */
|
||
|
|
opterr = 1;
|
||
|
|
optind = 1;
|
||
|
|
|
||
|
|
if (argc - fileind > 0) {
|
||
|
|
kernel = argv[fileind++];
|
||
|
|
}
|
||
|
|
if (argc - fileind > 0) {
|
||
|
|
output = argv[fileind++];
|
||
|
|
}
|
||
|
|
if (!kernel) {
|
||
|
|
error("No kernel specified!\n");
|
||
|
|
}
|
||
|
|
if (!output) {
|
||
|
|
error("No output file specified!\n");
|
||
|
|
}
|
||
|
|
if (argc - fileind > 0) {
|
||
|
|
error("%d extra options specified!\n", argc - fileind);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* slurp in the input kernel */
|
||
|
|
kernel_buf = slurp_decompress_file(kernel, &kernel_size);
|
||
|
|
|
||
|
|
/* Find/verify the kernel type */
|
||
|
|
for(i = 0; i < file_types; i++) {
|
||
|
|
char *reason;
|
||
|
|
if (type && (strcmp(type, file_type[i].name) != 0)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
reason = file_type[i].probe(kernel_buf, kernel_size);
|
||
|
|
if (reason == 0) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (type) {
|
||
|
|
die("Not %s: %s\n", type, reason);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (i == file_types) {
|
||
|
|
die("Can not determine the file type of %s\n", kernel);
|
||
|
|
}
|
||
|
|
result = file_type[i].mkelf(argc, argv, &hdr, kernel_buf, kernel_size);
|
||
|
|
if (result < 0) {
|
||
|
|
die("Cannot create %s result: %d\n", output, result);
|
||
|
|
}
|
||
|
|
/* open the output file */
|
||
|
|
write_elf(&hdr, output);
|
||
|
|
return 0;
|
||
|
|
}
|