Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 908ec7af authored by H. Peter Anvin's avatar H. Peter Anvin
Browse files

x86: remove arbitrary ELF section limit in i386 relocatable kernel 



Impact: build failure in maximal configurations

The 32-bit x86 relocatable kernel requires an auxilliary host program
to process the relocations.  This program had a hard-coded arbitrary
limit of a 100 ELF sections.  Instead of a hard-coded limit, allocate
the structures dynamically.

Signed-off-by: default avatarH. Peter Anvin <hpa@zytor.com>
Acked-by: default avatarVivek Goyal <vgoyal@redhat.com>
parent aa60d13f

arch/x86/boot/compressed/relocs.c

+110 −88
Original line number Diff line number Diff line
@@ -10,16 +10,20 @@ 
#define USE_BSD

#include <endian.h>



#define MAX_SHDRS 100

#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

static Elf32_Ehdr ehdr;

static Elf32_Shdr shdr[MAX_SHDRS];

static Elf32_Sym  *symtab[MAX_SHDRS];

static Elf32_Rel  *reltab[MAX_SHDRS];

static char *strtab[MAX_SHDRS];

static unsigned long reloc_count, reloc_idx;

static unsigned long *relocs;



struct section {

	Elf32_Shdr     shdr;

	struct section *link;

	Elf32_Sym      *symtab;

	Elf32_Rel      *reltab;

	char           *strtab;

};

static struct section *secs;



/*

 * Following symbols have been audited. There values are constant and do

 * not change if bzImage is loaded at a different physical address than
@@ -137,10 +141,10 @@ static const char *sec_name(unsigned shndx) 
{

	const char *sec_strtab;

	const char *name;

	sec_strtab = strtab[ehdr.e_shstrndx];

	sec_strtab = secs[ehdr.e_shstrndx].strtab;

	name = "<noname>";

	if (shndx < ehdr.e_shnum) {

		name = sec_strtab + shdr[shndx].sh_name;

		name = sec_strtab + secs[shndx].shdr.sh_name;

	}

	else if (shndx == SHN_ABS) {

		name = "ABSOLUTE";
@@ -159,7 +163,7 @@ static const char *sym_name(const char *sym_strtab, Elf32_Sym *sym) 
		name = sym_strtab + sym->st_name;

	}

	else {

		name = sec_name(shdr[sym->st_shndx].sh_name);

		name = sec_name(secs[sym->st_shndx].shdr.sh_name);

	}

	return name;

}
@@ -244,29 +248,34 @@ static void read_ehdr(FILE *fp) 
static void read_shdrs(FILE *fp)

{

	int i;

	if (ehdr.e_shnum > MAX_SHDRS) {

		die("%d section headers supported: %d\n",

			ehdr.e_shnum, MAX_SHDRS);

	Elf32_Shdr shdr;



	secs = calloc(ehdr.e_shnum, sizeof(struct section));

	if (!secs) {

		die("Unable to allocate %d section headers\n",

		    ehdr.e_shnum);

	}

	if (fseek(fp, ehdr.e_shoff, SEEK_SET) < 0) {

		die("Seek to %d failed: %s\n",

			ehdr.e_shoff, strerror(errno));

	}

	if (fread(&shdr, sizeof(shdr[0]), ehdr.e_shnum, fp) != ehdr.e_shnum) {

		die("Cannot read ELF section headers: %s\n",

			strerror(errno));

	}

	for (i = 0; i < ehdr.e_shnum; i++) {

		shdr[i].sh_name      = elf32_to_cpu(shdr[i].sh_name);

		shdr[i].sh_type      = elf32_to_cpu(shdr[i].sh_type);

		shdr[i].sh_flags     = elf32_to_cpu(shdr[i].sh_flags);

		shdr[i].sh_addr      = elf32_to_cpu(shdr[i].sh_addr);

		shdr[i].sh_offset    = elf32_to_cpu(shdr[i].sh_offset);

		shdr[i].sh_size      = elf32_to_cpu(shdr[i].sh_size);

		shdr[i].sh_link      = elf32_to_cpu(shdr[i].sh_link);

		shdr[i].sh_info      = elf32_to_cpu(shdr[i].sh_info);

		shdr[i].sh_addralign = elf32_to_cpu(shdr[i].sh_addralign);

		shdr[i].sh_entsize   = elf32_to_cpu(shdr[i].sh_entsize);

		struct section *sec = &secs[i];

		if (fread(&shdr, sizeof shdr, 1, fp) != 1)

			die("Cannot read ELF section headers %d/%d: %s\n",

			    i, ehdr.e_shnum, strerror(errno));

		sec->shdr.sh_name      = elf32_to_cpu(shdr.sh_name);

		sec->shdr.sh_type      = elf32_to_cpu(shdr.sh_type);

		sec->shdr.sh_flags     = elf32_to_cpu(shdr.sh_flags);

		sec->shdr.sh_addr      = elf32_to_cpu(shdr.sh_addr);

		sec->shdr.sh_offset    = elf32_to_cpu(shdr.sh_offset);

		sec->shdr.sh_size      = elf32_to_cpu(shdr.sh_size);

		sec->shdr.sh_link      = elf32_to_cpu(shdr.sh_link);

		sec->shdr.sh_info      = elf32_to_cpu(shdr.sh_info);

		sec->shdr.sh_addralign = elf32_to_cpu(shdr.sh_addralign);

		sec->shdr.sh_entsize   = elf32_to_cpu(shdr.sh_entsize);

		if (sec->shdr.sh_link < ehdr.e_shnum)

			sec->link = &secs[sec->shdr.sh_link];

	}



}
@@ -275,19 +284,21 @@ static void read_strtabs(FILE *fp) 
{

	int i;

	for (i = 0; i < ehdr.e_shnum; i++) {

		if (shdr[i].sh_type != SHT_STRTAB) {

		struct section *sec = &secs[i];

		if (sec->shdr.sh_type != SHT_STRTAB) {

			continue;

		}

		strtab[i] = malloc(shdr[i].sh_size);

		if (!strtab[i]) {

		sec->strtab = malloc(sec->shdr.sh_size);

		if (!sec->strtab) {

			die("malloc of %d bytes for strtab failed\n",

				shdr[i].sh_size);

				sec->shdr.sh_size);

		}

		if (fseek(fp, shdr[i].sh_offset, SEEK_SET) < 0) {

		if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) {

			die("Seek to %d failed: %s\n",

				shdr[i].sh_offset, strerror(errno));

				sec->shdr.sh_offset, strerror(errno));

		}

		if (fread(strtab[i], 1, shdr[i].sh_size, fp) != shdr[i].sh_size) {

		if (fread(sec->strtab, 1, sec->shdr.sh_size, fp)

		    != sec->shdr.sh_size) {

			die("Cannot read symbol table: %s\n",

				strerror(errno));

		}
@@ -298,27 +309,30 @@ static void read_symtabs(FILE *fp) 
{

	int i,j;

	for (i = 0; i < ehdr.e_shnum; i++) {

		if (shdr[i].sh_type != SHT_SYMTAB) {

		struct section *sec = &secs[i];

		if (sec->shdr.sh_type != SHT_SYMTAB) {

			continue;

		}

		symtab[i] = malloc(shdr[i].sh_size);

		if (!symtab[i]) {

		sec->symtab = malloc(sec->shdr.sh_size);

		if (!sec->symtab) {

			die("malloc of %d bytes for symtab failed\n",

				shdr[i].sh_size);

				sec->shdr.sh_size);

		}

		if (fseek(fp, shdr[i].sh_offset, SEEK_SET) < 0) {

		if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) {

			die("Seek to %d failed: %s\n",

				shdr[i].sh_offset, strerror(errno));

				sec->shdr.sh_offset, strerror(errno));

		}

		if (fread(symtab[i], 1, shdr[i].sh_size, fp) != shdr[i].sh_size) {

		if (fread(sec->symtab, 1, sec->shdr.sh_size, fp)

		    != sec->shdr.sh_size) {

			die("Cannot read symbol table: %s\n",

				strerror(errno));

		}

		for(j = 0; j < shdr[i].sh_size/sizeof(symtab[i][0]); j++) {

			symtab[i][j].st_name  = elf32_to_cpu(symtab[i][j].st_name);

			symtab[i][j].st_value = elf32_to_cpu(symtab[i][j].st_value);

			symtab[i][j].st_size  = elf32_to_cpu(symtab[i][j].st_size);

			symtab[i][j].st_shndx = elf16_to_cpu(symtab[i][j].st_shndx);

		for (j = 0; j < sec->shdr.sh_size/sizeof(Elf32_Sym); j++) {

			Elf32_Sym *sym = &sec->symtab[j];

			sym->st_name  = elf32_to_cpu(sym->st_name);

			sym->st_value = elf32_to_cpu(sym->st_value);

			sym->st_size  = elf32_to_cpu(sym->st_size);

			sym->st_shndx = elf16_to_cpu(sym->st_shndx);

		}

	}

}
@@ -328,25 +342,28 @@ static void read_relocs(FILE *fp) 
{

	int i,j;

	for (i = 0; i < ehdr.e_shnum; i++) {

		if (shdr[i].sh_type != SHT_REL) {

		struct section *sec = &secs[i];

		if (sec->shdr.sh_type != SHT_REL) {

			continue;

		}

		reltab[i] = malloc(shdr[i].sh_size);

		if (!reltab[i]) {

		sec->reltab = malloc(sec->shdr.sh_size);

		if (!sec->reltab) {

			die("malloc of %d bytes for relocs failed\n",

				shdr[i].sh_size);

				sec->shdr.sh_size);

		}

		if (fseek(fp, shdr[i].sh_offset, SEEK_SET) < 0) {

		if (fseek(fp, sec->shdr.sh_offset, SEEK_SET) < 0) {

			die("Seek to %d failed: %s\n",

				shdr[i].sh_offset, strerror(errno));

				sec->shdr.sh_offset, strerror(errno));

		}

		if (fread(reltab[i], 1, shdr[i].sh_size, fp) != shdr[i].sh_size) {

		if (fread(sec->reltab, 1, sec->shdr.sh_size, fp)

		    != sec->shdr.sh_size) {

			die("Cannot read symbol table: %s\n",

				strerror(errno));

		}

		for(j = 0; j < shdr[i].sh_size/sizeof(reltab[0][0]); j++) {

			reltab[i][j].r_offset = elf32_to_cpu(reltab[i][j].r_offset);

			reltab[i][j].r_info   = elf32_to_cpu(reltab[i][j].r_info);

		for (j = 0; j < sec->shdr.sh_size/sizeof(Elf32_Rel); j++) {

			Elf32_Rel *rel = &sec->reltab[j];

			rel->r_offset = elf32_to_cpu(rel->r_offset);

			rel->r_info   = elf32_to_cpu(rel->r_info);

		}

	}

}
@@ -358,18 +375,20 @@ static void print_absolute_symbols(void) 
	printf("Absolute symbols\n");

	printf(" Num:    Value Size  Type       Bind        Visibility  Name\n");

	for (i = 0; i < ehdr.e_shnum; i++) {

		struct section *sec = &secs[i];

		char *sym_strtab;

		Elf32_Sym *sh_symtab;

		int j;

		if (shdr[i].sh_type != SHT_SYMTAB) {



		if (sec->shdr.sh_type != SHT_SYMTAB) {

			continue;

		}

		sh_symtab = symtab[i];

		sym_strtab = strtab[shdr[i].sh_link];

		for(j = 0; j < shdr[i].sh_size/sizeof(symtab[0][0]); j++) {

		sh_symtab = sec->symtab;

		sym_strtab = sec->link->strtab;

		for (j = 0; j < sec->shdr.sh_size/sizeof(Elf32_Sym); j++) {

			Elf32_Sym *sym;

			const char *name;

			sym = &symtab[i][j];

			sym = &sec->symtab[j];

			name = sym_name(sym_strtab, sym);

			if (sym->st_shndx != SHN_ABS) {

				continue;
@@ -390,25 +409,26 @@ static void print_absolute_relocs(void) 
	int i, printed = 0;



	for (i = 0; i < ehdr.e_shnum; i++) {

		struct section *sec = &secs[i];

		struct section *sec_applies, *sec_symtab;

		char *sym_strtab;

		Elf32_Sym *sh_symtab;

		unsigned sec_applies, sec_symtab;

		int j;

		if (shdr[i].sh_type != SHT_REL) {

		if (sec->shdr.sh_type != SHT_REL) {

			continue;

		}

		sec_symtab  = shdr[i].sh_link;

		sec_applies = shdr[i].sh_info;

		if (!(shdr[sec_applies].sh_flags & SHF_ALLOC)) {

		sec_symtab  = sec->link;

		sec_applies = &secs[sec->shdr.sh_info];

		if (!(sec_applies->shdr.sh_flags & SHF_ALLOC)) {

			continue;

		}

		sh_symtab = symtab[sec_symtab];

		sym_strtab = strtab[shdr[sec_symtab].sh_link];

		for(j = 0; j < shdr[i].sh_size/sizeof(reltab[0][0]); j++) {

		sh_symtab  = sec_symtab->symtab;

		sym_strtab = sec_symtab->link->strtab;

		for (j = 0; j < sec->shdr.sh_size/sizeof(Elf32_Rel); j++) {

			Elf32_Rel *rel;

			Elf32_Sym *sym;

			const char *name;

			rel = &reltab[i][j];

			rel = &sec->reltab[j];

			sym = &sh_symtab[ELF32_R_SYM(rel->r_info)];

			name = sym_name(sym_strtab, sym);

			if (sym->st_shndx != SHN_ABS) {
@@ -459,23 +479,25 @@ static void walk_relocs(void (*visit)(Elf32_Rel *rel, Elf32_Sym *sym)) 
	for (i = 0; i < ehdr.e_shnum; i++) {

		char *sym_strtab;

		Elf32_Sym *sh_symtab;

		unsigned sec_applies, sec_symtab;

		struct section *sec_applies, *sec_symtab;

		int j;

		if (shdr[i].sh_type != SHT_REL) {

		struct section *sec = &secs[i];



		if (sec->shdr.sh_type != SHT_REL) {

			continue;

		}

		sec_symtab  = shdr[i].sh_link;

		sec_applies = shdr[i].sh_info;

		if (!(shdr[sec_applies].sh_flags & SHF_ALLOC)) {

		sec_symtab  = sec->link;

		sec_applies = &secs[sec->shdr.sh_info];

		if (!(sec_applies->shdr.sh_flags & SHF_ALLOC)) {

			continue;

		}

		sh_symtab = symtab[sec_symtab];

		sym_strtab = strtab[shdr[sec_symtab].sh_link];

		for(j = 0; j < shdr[i].sh_size/sizeof(reltab[0][0]); j++) {

		sh_symtab = sec_symtab->symtab;

		sym_strtab = sec->link->strtab;

		for (j = 0; j < sec->shdr.sh_size/sizeof(Elf32_Rel); j++) {

			Elf32_Rel *rel;

			Elf32_Sym *sym;

			unsigned r_type;

			rel = &reltab[i][j];

			rel = &sec->reltab[j];

			sym = &sh_symtab[ELF32_R_SYM(rel->r_info)];

			r_type = ELF32_R_TYPE(rel->r_info);

			/* Don't visit relocations to absolute symbols */