static int
process_file(Elf *elf, char *cur_file, Cmd_Info *cmd_info)
{
int error = SUCCESS;
int x;
GElf_Ehdr ehdr;
size_t shnum;
/*
* Initialize
*/
if (gelf_getehdr(elf, &ehdr) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (elf_getshnum(elf, &shnum) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
initialize(shnum, cmd_info);
if (ehdr.e_phnum != 0) {
if (build_segment_table(elf, &ehdr) == FAILURE)
return (FAILURE);
}
if ((x = traverse_file(elf, &ehdr, cur_file, cmd_info)) ==
FAILURE) {
error_message(WRN_MANIPULATED_ERROR,
PLAIN_ERROR, (char *)0,
prog, cur_file);
error = FAILURE;
} else if (x != DONT_BUILD && x != FAILURE) {
post_process(cmd_info);
if (build_file(elf, &ehdr, cmd_info) == FAILURE) {
error_message(WRN_MANIPULATED_ERROR,
PLAIN_ERROR, (char *)0,
prog, cur_file);
error = FAILURE;
}
}
free(off_table);
free(sec_table);
free(nobits_table);
if (x == DONT_BUILD)
return (DONT_BUILD);
else
return (error);
}
static int
build_file(Elf *src_elf, GElf_Ehdr *src_ehdr, Cmd_Info *cmd_info)
{
Elf_Scn *src_scn;
Elf_Scn *dst_scn;
int new_sh_name = 0; /* to hold the offset for the new */
/* section's name */
Elf *dst_elf = 0;
Elf_Data *elf_data;
Elf_Data *data;
int64_t scn_no, x;
size_t no_of_symbols = 0;
section_info_table *info;
unsigned int c = 0;
int fdtmp;
GElf_Shdr src_shdr;
GElf_Shdr dst_shdr;
GElf_Ehdr dst_ehdr;
GElf_Off new_offset = 0, r;
size_t shnum, shstrndx;
if (elf_getshnum(src_elf, &shnum) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (elf_getshstrndx(src_elf, &shstrndx) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if ((fdtmp = open(elftmpfile, O_RDWR |
O_TRUNC | O_CREAT, (mode_t)0666)) == -1) {
error_message(OPEN_TEMP_ERROR,
SYSTEM_ERROR, strerror(errno),
prog, elftmpfile);
return (FAILURE);
}
if ((dst_elf = elf_begin(fdtmp, ELF_C_WRITE, (Elf *) 0)) == NULL) {
error_message(READ_ERROR,
LIBelf_ERROR, elf_errmsg(-1),
prog, elftmpfile);
(void) close(fdtmp);
return (FAILURE);
}
if (gelf_newehdr(dst_elf, gelf_getclass(src_elf)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
/* initialize dst_ehdr */
(void) gelf_getehdr(dst_elf, &dst_ehdr);
dst_ehdr = *src_ehdr;
/*
* flush the changes to the ehdr so the
* ident array is filled in.
*/
(void) gelf_update_ehdr(dst_elf, &dst_ehdr);
if (src_ehdr->e_phnum != 0) {
(void) elf_flagelf(dst_elf, ELF_C_SET, ELF_F_LAYOUT);
if (gelf_newphdr(dst_elf, src_ehdr->e_phnum) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
for (x = 0; x < src_ehdr->e_phnum; ++x) {
GElf_Phdr dst;
GElf_Phdr src;
/* LINTED */
(void) gelf_getphdr(src_elf, (int)x, &src);
/* LINTED */
(void) gelf_getphdr(dst_elf, (int)x, &dst);
(void) memcpy(&dst, &src, sizeof (GElf_Phdr));
/* LINTED */
(void) gelf_update_phdr(dst_elf, (int)x, &dst);
}
x = location(dst_ehdr.e_phoff, 0, src_elf);
if (x == AFTER)
new_offset = (GElf_Off)src_ehdr->e_ehsize;
}
scn_no = 1;
while ((src_scn = sec_table[scn_no].scn) != (Elf_Scn *) -1) {
info = &sec_table[scn_no];
/* If section should be copied to new file NOW */
if ((info->secno != (GElf_Word)DELETED) &&
info->secno <= scn_no) {
if ((dst_scn = elf_newscn(dst_elf)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) gelf_getshdr(dst_scn, &dst_shdr);
(void) gelf_getshdr(info->scn, &src_shdr);
(void) memcpy(&dst_shdr, &src_shdr, sizeof (GElf_Shdr));
/*
* Update link and info fields
* The sh_link field may have special values so
* check them first.
*/
if ((src_shdr.sh_link >= shnum) ||
(src_shdr.sh_link == 0))
dst_shdr.sh_link = src_shdr.sh_link;
else if ((int)sec_table[src_shdr.sh_link].secno < 0)
dst_shdr.sh_link = 0;
else
dst_shdr.sh_link =
sec_table[src_shdr.sh_link].secno;
if ((src_shdr.sh_type == SHT_REL) ||
(src_shdr.sh_type == SHT_RELA)) {
if ((src_shdr.sh_info >= shnum) ||
((int)sec_table[src_shdr.
sh_info].secno < 0))
dst_shdr.sh_info = 0;
else
dst_shdr.sh_info =
sec_table[src_shdr.sh_info].secno;
}
data = sec_table[scn_no].data;
if ((elf_data = elf_newdata(dst_scn)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
*elf_data = *data;
/* SHT_{DYNSYM, SYMTAB} might need some change */
if (((src_shdr.sh_type == SHT_SYMTAB) ||
(src_shdr.sh_type == SHT_DYNSYM)) &&
src_shdr.sh_entsize != 0 &&
(cmd_info->no_of_delete != 0 ||
cmd_info->no_of_nulled != 0)) {
char *new_sym;
no_of_symbols = src_shdr.sh_size /
src_shdr.sh_entsize;
new_sym = malloc(no_of_symbols *
src_shdr.sh_entsize);
if (new_sym == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0, prog);
mcs_exit(FAILURE);
}
/* CSTYLED */
elf_data->d_buf = (void *) new_sym;
for (c = 0; c < no_of_symbols; c++) {
GElf_Sym csym;
(void) gelf_getsym(data, c, &csym);
if ((csym.st_shndx < SHN_LORESERVE) &&
(csym.st_shndx != SHN_UNDEF)) {
section_info_table *i;
i = &sec_table[csym.st_shndx];
if (((int)i->secno !=
DELETED) &&
((int)i->secno != NULLED))
csym.st_shndx =
i->secno;
else {
if (src_shdr.sh_type ==
SHT_SYMTAB)
/*
* The section which
* this * symbol relates
* to is removed.
* There is no way to
* specify this fact,
* just change the shndx
* to 1.
*/
csym.st_shndx = 1;
else {
/*
* If this is in a
* .dynsym, NULL it out.
*/
csym.st_shndx = 0;
csym.st_name = 0;
csym.st_value = 0;
csym.st_size = 0;
csym.st_info = 0;
csym.st_other = 0;
csym.st_shndx = 0;
}
}
}
(void) gelf_update_sym(elf_data, c,
&csym);
}
}
/* update SHT_SYMTAB_SHNDX */
if ((src_shdr.sh_type == SHT_SYMTAB_SHNDX) &&
(src_shdr.sh_entsize != 0) &&
((cmd_info->no_of_delete != 0) ||
(cmd_info->no_of_nulled != 0))) {
GElf_Word *oldshndx;
GElf_Word *newshndx;
uint_t entcnt;
entcnt = src_shdr.sh_size /
src_shdr.sh_entsize;
oldshndx = data->d_buf;
newshndx = malloc(entcnt *
src_shdr.sh_entsize);
if (newshndx == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0, prog);
mcs_exit(FAILURE);
}
elf_data->d_buf = (void *)newshndx;
for (c = 0; c < entcnt; c++) {
if (oldshndx[c] != SHN_UNDEF) {
section_info_table *i;
i = &sec_table[oldshndx[c]];
if (((int)i->secno !=
DELETED) &&
((int)i->secno != NULLED))
newshndx[c] = i->secno;
else
newshndx[c] =
oldshndx[c];
} else
newshndx[c] =
oldshndx[c];
}
}
/*
* If the section is to be updated,
* do so.
*/
if (ISCANDIDATE(info->flags)) {
if ((GET_LOC(info->flags) == PRIOR) &&
(((int)info->secno == NULLED) ||
((int)info->secno == EXPANDED) ||
((int)info->secno == SHRUNK))) {
/*
* The section is updated,
* but the position is not too
* good. Need to NULL this out.
*/
dst_shdr.sh_name = 0;
dst_shdr.sh_type = SHT_PROGBITS;
if ((int)info->secno != NULLED) {
(cmd_info->no_of_moved)++;
SET_MOVING(info->flags);
}
} else {
/*
* The section is positioned AFTER,
* or there are no segments.
* It is safe to update this section.
*/
data = sec_table[scn_no].mdata;
*elf_data = *data;
dst_shdr.sh_size = elf_data->d_size;
}
}
/* add new section name to shstrtab? */
else if (!Sect_exists &&
(new_sec_string != NULL) &&
(scn_no == shstrndx) &&
(dst_shdr.sh_type == SHT_STRTAB) &&
((src_ehdr->e_phnum == 0) ||
((x = scn_location(dst_scn, dst_elf)) != IN) ||
(x != PRIOR))) {
size_t sect_len;
sect_len = strlen(SECT_NAME);
if ((elf_data->d_buf =
malloc((dst_shdr.sh_size +
sect_len + 1))) == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0, prog);
mcs_exit(FAILURE);
}
/* put original data plus new data in section */
(void) memcpy(elf_data->d_buf,
data->d_buf, data->d_size);
(void) memcpy(&((char *)elf_data->d_buf)
[data->d_size],
SECT_NAME,
sect_len + 1);
/* LINTED */
new_sh_name = (int)dst_shdr.sh_size;
dst_shdr.sh_size += sect_len + 1;
elf_data->d_size += sect_len + 1;
}
/*
* Compute offsets.
*/
if (src_ehdr->e_phnum != 0) {
/*
* Compute section offset.
*/
if (off_table[scn_no] == 0) {
if (dst_shdr.sh_addralign != 0) {
r = new_offset %
dst_shdr.sh_addralign;
if (r)
new_offset +=
dst_shdr.sh_addralign - r;
}
dst_shdr.sh_offset = new_offset;
elf_data->d_off = 0;
} else {
if (nobits_table[scn_no] == 0)
new_offset = off_table[scn_no];
}
if (nobits_table[scn_no] == 0)
new_offset += dst_shdr.sh_size;
}
}
(void) gelf_update_shdr(dst_scn, &dst_shdr); /* flush changes */
scn_no++;
}
/*
* This is the real new section.
*/
if (!Sect_exists && new_sec_string != NULL) {
size_t string_size;
string_size = strlen(new_sec_string) + 1;
if ((dst_scn = elf_newscn(dst_elf)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) gelf_getshdr(dst_scn, &dst_shdr);
dst_shdr.sh_name = new_sh_name;
dst_shdr.sh_type = SHT_PROGBITS;
dst_shdr.sh_flags = 0;
dst_shdr.sh_addr = 0;
if (src_ehdr->e_phnum != NULL)
dst_shdr.sh_offset = new_offset;
else
dst_shdr.sh_offset = 0;
dst_shdr.sh_size = string_size + 1;
dst_shdr.sh_link = 0;
dst_shdr.sh_info = 0;
dst_shdr.sh_addralign = 1;
dst_shdr.sh_entsize = 0;
(void) gelf_update_shdr(dst_scn, &dst_shdr); /* flush changes */
if ((elf_data = elf_newdata(dst_scn)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
elf_data->d_size = string_size + 1;
if ((elf_data->d_buf = (char *)
calloc(1, string_size + 1)) == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0,
prog);
mcs_exit(FAILURE);
}
(void) memcpy(&((char *)elf_data->d_buf)[1],
new_sec_string, string_size);
elf_data->d_align = 1;
new_offset += string_size + 1;
}
/*
* If there are sections which needed to be moved,
* then do it here.
*/
if (cmd_info->no_of_moved != 0) {
int cnt;
info = &sec_table[0];
for (cnt = 0; cnt < shnum; cnt++, info++) {
if ((GET_MOVING(info->flags)) == 0)
continue;
if ((src_scn = elf_getscn(src_elf, info->osecno)) ==
NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (gelf_getshdr(src_scn, &src_shdr) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if ((dst_scn = elf_newscn(dst_elf)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (gelf_getshdr(dst_scn, &dst_shdr) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
dst_shdr = src_shdr;
data = info->mdata;
dst_shdr.sh_offset = new_offset; /* UPDATE fields */
dst_shdr.sh_size = data->d_size;
if ((shnum >= src_shdr.sh_link) ||
(src_shdr.sh_link == 0))
dst_shdr.sh_link = src_shdr.sh_link;
else
dst_shdr.sh_link =
sec_table[src_shdr.sh_link].osecno;
if ((shnum >= src_shdr.sh_info) ||
(src_shdr.sh_info == 0))
dst_shdr.sh_info = src_shdr.sh_info;
else
dst_shdr.sh_info =
sec_table[src_shdr.sh_info].osecno;
(void) gelf_update_shdr(dst_scn, &dst_shdr);
if ((elf_data = elf_newdata(dst_scn)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) memcpy(elf_data, data, sizeof (Elf_Data));
new_offset += data->d_size;
}
}
/*
* In the event that the position of the sting table has changed,
* as a result of deleted sections, update the ehdr->e_shstrndx.
*/
if ((shstrndx > 0) && (shnum > 0) &&
(sec_table[shstrndx].secno < shnum)) {
if (sec_table[shstrndx].secno < SHN_LORESERVE) {
dst_ehdr.e_shstrndx =
sec_table[dst_ehdr.e_shstrndx].secno;
} else {
Elf_Scn *_scn;
GElf_Shdr shdr0;
/*
* If shstrndx requires 'Extended ELF Sections'
* then it is stored in shdr[0].sh_link
*/
dst_ehdr.e_shstrndx = SHN_XINDEX;
if ((_scn = elf_getscn(dst_elf, 0)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) gelf_getshdr(_scn, &shdr0);
shdr0.sh_link = sec_table[shstrndx].secno;
(void) gelf_update_shdr(_scn, &shdr0);
}
}
if (src_ehdr->e_phnum != 0) {
size_t align = gelf_fsize(dst_elf, ELF_T_ADDR, 1, EV_CURRENT);
/* UPDATE location of program header table */
if (location(dst_ehdr.e_phoff, 0, dst_elf) == AFTER) {
r = new_offset % align;
if (r)
new_offset += align - r;
dst_ehdr.e_phoff = new_offset;
new_offset += dst_ehdr.e_phnum
* dst_ehdr.e_phentsize;
}
/* UPDATE location of section header table */
if ((location(dst_ehdr.e_shoff, 0, src_elf) == AFTER) ||
((location(dst_ehdr.e_shoff, 0, src_elf) == PRIOR) &&
(!Sect_exists && new_sec_string != NULL))) {
r = new_offset % align;
if (r)
new_offset += align - r;
dst_ehdr.e_shoff = new_offset;
}
free(b_e_seg_table);
/*
* The NOTE segment is the one segment whos
* sections might get moved by mcs processing.
* Make sure that the NOTE segments offset points
* to the .note section.
*/
if ((notesegndx != -1) && (notesctndx != -1) &&
(sec_table[notesctndx].secno)) {
Elf_Scn * notescn;
GElf_Shdr nshdr;
notescn = elf_getscn(dst_elf,
sec_table[notesctndx].secno);
(void) gelf_getshdr(notescn, &nshdr);
if (gelf_getclass(dst_elf) == ELFCLASS32) {
Elf32_Phdr * ph = elf32_getphdr(dst_elf) +
notesegndx;
/* LINTED */
ph->p_offset = (Elf32_Off)nshdr.sh_offset;
} else {
Elf64_Phdr * ph = elf64_getphdr(dst_elf) +
notesegndx;
ph->p_offset = (Elf64_Off)nshdr.sh_offset;
}
}
}
/* copy ehdr changes back into real ehdr */
(void) gelf_update_ehdr(dst_elf, &dst_ehdr);
if (elf_update(dst_elf, ELF_C_WRITE) < 0) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) elf_end(dst_elf);
(void) close(fdtmp);
return (SUCCESS);
}
static int
traverse_file(Elf *elf, GElf_Ehdr * ehdr, char *cur_file, Cmd_Info *cmd_info)
{
Elf_Scn * scn;
Elf_Scn * temp_scn;
Elf_Data * data;
GElf_Shdr * shdr;
char *temp_name;
section_info_table * sinfo;
GElf_Xword x;
int ret = 0, SYM = 0; /* used by strip command */
int phnum = ehdr->e_phnum;
unsigned int i, scn_index;
size_t shstrndx, shnum;
Sect_exists = 0;
if (elf_getshnum(elf, &shnum) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (elf_getshstrndx(elf, &shstrndx) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
scn = 0;
scn_index = 1;
sinfo = &sec_table[scn_index];
while ((scn = elf_nextscn(elf, scn)) != 0) {
char *name;
shdr = &(sinfo->shdr);
if (gelf_getshdr(scn, shdr) == NULL) {
error_message(NO_SECT_TABLE_ERROR,
LIBelf_ERROR, elf_errmsg(-1),
prog, cur_file);
return (FAILURE);
} else {
name = elf_strptr(elf, shstrndx,
(size_t)shdr->sh_name);
if (name == NULL)
name = "_@@@###";
}
sinfo->scn = scn;
sinfo->secno = scn_index;
sinfo->osecno = scn_index;
SET_ACTION(sinfo->flags, ACT_NOP);
sinfo->name = name;
if (ehdr->e_phnum == 0)
SET_LOC(sinfo->flags, NOSEG);
else
SET_LOC(sinfo->flags, scn_location(scn, elf));
if (shdr->sh_type == SHT_GROUP) {
if (list_appendc(&cmd_info->sh_groups, sinfo) == 0) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0, prog);
mcs_exit(FAILURE);
}
}
/*
* If the target section is pointed by a section
* holding relocation infomation, then the
* pointing section would be useless if the
* target section is removed.
*/
if ((shdr->sh_type == SHT_REL ||
shdr->sh_type == SHT_RELA) &&
(shdr->sh_info != SHN_UNDEF &&
(temp_scn = elf_getscn(elf, shdr->sh_info)) != 0)) {
GElf_Shdr tmp_shdr;
if (gelf_getshdr(temp_scn, &tmp_shdr) != NULL) {
temp_name = elf_strptr(elf, shstrndx,
(size_t)tmp_shdr.sh_name);
sinfo->rel_name = temp_name;
sinfo->rel_scn_index =
shdr->sh_info;
if (phnum == 0)
sinfo->rel_loc = NOSEG;
else
sinfo->rel_loc =
scn_location(temp_scn, elf);
}
}
data = 0;
if ((data = elf_getdata(scn, data)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
sinfo->data = data;
/*
* Check if this section is a candidate for
* action to be processes.
*/
if (sectcmp(name) == 0) {
SET_CANDIDATE(sinfo->flags);
/*
* This flag just shows that there was a
* candidate.
*/
Sect_exists++;
}
/*
* Any of the following section types should
* also be removed (if possible) if invoked via
* the 'strip' command.
*/
if (CHK_OPT(cmd_info, I_AM_STRIP) &&
((shdr->sh_type == SHT_SUNW_DEBUG) ||
(shdr->sh_type == SHT_SUNW_DEBUGSTR))) {
SET_CANDIDATE(sinfo->flags);
Sect_exists++;
}
/*
* Zap this file ?
*/
if ((cmd_info->flags & zFLAG) &&
(shdr->sh_type == SHT_PROGBITS)) {
SET_CANDIDATE(sinfo->flags);
Sect_exists++;
}
x = GET_LOC(sinfo->flags);
/*
* Remeber the note sections index so that we can
* reset the NOTE segments offset to point to it.
*
* It may have been assigned a new location in the
* resulting output elf image.
*/
if (shdr->sh_type == SHT_NOTE)
notesctndx = scn_index;
if (x == IN || x == PRIOR)
off_table[scn_index] =
shdr->sh_offset;
if (shdr->sh_type == SHT_NOBITS)
nobits_table[scn_index] = 1;
/*
* If this section satisfies the condition,
* apply the actions specified.
*/
if (ISCANDIDATE(sinfo->flags)) {
ret += apply_action(sinfo, cur_file, cmd_info);
}
/*
* If I am strip command, determine if symtab can go or not.
*/
if (CHK_OPT(cmd_info, I_AM_STRIP) &&
(CHK_OPT(cmd_info, xFLAG) == 0) &&
(CHK_OPT(cmd_info, lFLAG) == 0)) {
if (shdr->sh_type == SHT_SYMTAB &&
GET_LOC(sinfo->flags) == AFTER) {
SYM = scn_index;
}
}
scn_index++;
sinfo++;
}
sinfo->scn = (Elf_Scn *) -1;
/*
* If there were any errors traversing the file,
* just return error.
*/
if (ret != 0)
return (FAILURE);
/*
* Remove symbol table if possible
*/
if (CHK_OPT(cmd_info, I_AM_STRIP) && SYM != 0) {
GElf_Shdr tmp_shdr;
(void) gelf_getshdr(sec_table[SYM].scn, &tmp_shdr);
sec_table[SYM].secno = (GElf_Word)DELETED;
++(cmd_info->no_of_nulled);
if (Sect_exists == 0)
++Sect_exists;
SET_ACTION(sec_table[SYM].flags, ACT_DELETE);
off_table[SYM] = 0;
/*
* Can I remove section header
* string table ?
*/
if ((tmp_shdr.sh_link < shnum) &&
(tmp_shdr.sh_link != SHN_UNDEF) &&
(tmp_shdr.sh_link != shstrndx) &&
(GET_LOC(sec_table[tmp_shdr.sh_link].flags) == AFTER)) {
sec_table[tmp_shdr.sh_link].secno = (GElf_Word)DELETED;
++(cmd_info->no_of_nulled);
if (Sect_exists == 0)
++Sect_exists;
SET_ACTION(sec_table[tmp_shdr.sh_link].flags,\
ACT_DELETE);
off_table[tmp_shdr.sh_link] = 0;
}
}
/*
* If I only printed the contents, then
* just report so.
*/
if (CHK_OPT(cmd_info, pFLAG) && !CHK_OPT(cmd_info, MIGHT_CHG))
return (DONT_BUILD); /* don't bother creating a new file */
/* since the file has not changed */
/*
* I might need to add a new section. Check it.
*/
if (Sect_exists == 0 && CHK_OPT(cmd_info, aFLAG)) {
int act = 0;
new_sec_string = calloc(1, cmd_info->str_size + 1);
if (new_sec_string == NULL)
return (FAILURE);
for (act = 0; act < actmax; act++) {
if (Action[act].a_action == ACT_APPEND) {
(void) strcat(new_sec_string,
Action[act].a_string);
(void) strcat(new_sec_string, "\n");
cmd_info->no_of_append = 1;
}
}
}
/*
* If I did not append any new sections, and I did not
* modify/delete any sections, then just report so.
*/
if ((Sect_exists == 0 && cmd_info->no_of_append == 0) ||
!CHK_OPT(cmd_info, MIGHT_CHG))
return (DONT_BUILD);
/*
* Found at least one section which was processed.
* Deleted or Appended or Compressed.
*/
if (Sect_exists) {
/*
* First, handle the deleted sections.
*/
if (cmd_info->no_of_delete != 0 ||
cmd_info->no_of_nulled != 0) {
int acc = 0;
int rel_idx;
/*
* Handle relocation/target
* sections.
*/
sinfo = &(sec_table[0]);
for (i = 1; i < shnum; i++) {
sinfo++;
rel_idx = sinfo->rel_scn_index;
if (rel_idx == 0)
continue;
/*
* If I am removed, then remove my
* target section.
*/
if (((sinfo->secno ==
(GElf_Word)DELETED) ||
(sinfo->secno ==
(GElf_Word)NULLED)) &&
sinfo->rel_loc != IN) {
if (GET_LOC(sec_table[rel_idx].flags) ==
PRIOR)
sec_table[rel_idx].secno =
(GElf_Word)NULLED;
else
sec_table[rel_idx].secno =
(GElf_Word)DELETED;
SET_ACTION(sec_table[rel_idx].flags,\
ACT_DELETE);
}
/*
* I am not removed. Check if my target is
* removed or nulled. If so, let me try to
* remove my self.
*/
if (((sec_table[rel_idx].secno ==
(GElf_Word)DELETED) ||
(sec_table[rel_idx].secno ==
(GElf_Word)NULLED)) &&
(GET_LOC(sinfo->flags) != IN)) {
if (GET_LOC(sinfo->flags) ==
PRIOR)
sinfo->secno =
(GElf_Word)NULLED;
else
sinfo->secno =
(GElf_Word)DELETED;
SET_ACTION(sinfo->flags,\
ACT_DELETE);
}
}
/*
* Now, take care of DELETED sections
*/
sinfo = &(sec_table[1]);
for (i = 1; i < shnum; i++) {
shdr = &(sinfo->shdr);
if (sinfo->secno == (GElf_Word)DELETED) {
acc++;
/*
* The SHT_GROUP section which this section
* is a member may be able to be removed.
* See post_process().
*/
if (shdr->sh_flags & SHF_GROUP)
cmd_info->flags |= SHF_GROUP_DEL;
} else {
/*
* The data buffer of SHT_GROUP this section
* is a member needs to be updated.
* See post_process().
*/
sinfo->secno -= acc;
if ((shdr->sh_flags &
SHF_GROUP) && (acc != 0))
cmd_info->flags |= SHF_GROUP_MOVE;
}
sinfo++;
}
}
}
/*
* I know that the file has been modified.
* A new file need to be created.
*/
return (SUCCESS);
}
void clone_elf(Elf *elf, Elf *newelf,
const char *elf_name,
const char *newelf_name,
bool *sym_filter, int num_symbols,
int shady
#ifdef SUPPORT_ANDROID_PRELINK_TAGS
, int *prelinked,
int *elf_little,
long *prelink_addr
#endif
, bool rebuild_shstrtab,
bool strip_debug,
bool dry_run)
{
GElf_Ehdr ehdr_mem, *ehdr; /* store ELF header of original library */
size_t shstrndx; /* section-strings-section index */
size_t shnum; /* number of sections in the original file */
/* string table for section headers in new file */
struct Ebl_Strtab *shst = NULL;
int dynamic_idx = -1; /* index in shdr_info[] of .dynamic section */
int dynsym_idx = -1; /* index in shdr_info[] of dynamic symbol table
section */
unsigned int cnt; /* general-purpose counter */
/* This flag is true when at least one section is dropped or when the
relative order of sections has changed, so that section indices in
the resulting file will be different from those in the original. */
bool sections_dropped_or_rearranged;
Elf_Scn *scn; /* general-purpose section */
size_t idx; /* general-purporse section index */
shdr_info_t *shdr_info = NULL;
unsigned int shdr_info_len = 0;
GElf_Phdr *phdr_info = NULL;
/* Get the information from the old file. */
ehdr = gelf_getehdr (elf, &ehdr_mem);
FAILIF_LIBELF(NULL == ehdr, gelf_getehdr);
/* Create new program header for the elf file */
FAILIF(gelf_newehdr (newelf, gelf_getclass (elf)) == 0 ||
(ehdr->e_type != ET_REL && gelf_newphdr (newelf,
ehdr->e_phnum) == 0),
"Cannot create new file: %s", elf_errmsg (-1));
#ifdef SUPPORT_ANDROID_PRELINK_TAGS
ASSERT(prelinked);
ASSERT(prelink_addr);
ASSERT(elf_little);
*elf_little = (ehdr->e_ident[EI_DATA] == ELFDATA2LSB);
*prelinked = check_prelinked(elf_name, *elf_little, prelink_addr);
#endif
INFO("\n\nCALCULATING MODIFICATIONS\n\n");
/* Copy out the old program header: notice that if the ELF file does not
have a program header, this loop won't execute.
*/
INFO("Copying ELF program header...\n");
phdr_info = (GElf_Phdr *)CALLOC(ehdr->e_phnum, sizeof(GElf_Phdr));
for (cnt = 0; cnt < ehdr->e_phnum; ++cnt) {
INFO("\tRetrieving entry %d\n", cnt);
FAILIF_LIBELF(NULL == gelf_getphdr(elf, cnt, phdr_info + cnt),
gelf_getphdr);
/* -- we update the header at the end
FAILIF_LIBELF(gelf_update_phdr (newelf, cnt, phdr_info + cnt) == 0,
gelf_update_phdr);
*/
}
/* Get the section-header strings section. This section contains the
strings used to name the other sections. */
FAILIF_LIBELF(elf_getshstrndx(elf, &shstrndx) < 0, elf_getshstrndx);
/* Get the number of sections. */
FAILIF_LIBELF(elf_getshnum (elf, &shnum) < 0, elf_getshnum);
INFO("Original ELF file has %zd sections.\n", shnum);
/* Allocate the section-header-info buffer. We allocate one more entry
for the section-strings section because we regenerate that one and
place it at the very end of the file. Note that just because we create
an extra entry in the shdr_info array, it does not mean that we create
one more section the header. We just mark the old section for removal
and create one as the last section.
*/
INFO("Allocating section-header info structure (%zd) bytes...\n",
shnum*sizeof (shdr_info_t));
shdr_info_len = rebuild_shstrtab ? shnum + 1 : shnum;
shdr_info = (shdr_info_t *)CALLOC(shdr_info_len, sizeof (shdr_info_t));
/* Iterate over all the sections and initialize the internal section-info
array...
*/
INFO("Initializing section-header info structure...\n");
/* Gather information about the sections in this file. */
scn = NULL;
cnt = 1;
while ((scn = elf_nextscn (elf, scn)) != NULL) {
ASSERT(elf_ndxscn(scn) == cnt);
shdr_info[cnt].scn = scn;
FAILIF_LIBELF(NULL == gelf_getshdr(scn, &shdr_info[cnt].shdr),
gelf_getshdr);
/* Get the name of the section. */
shdr_info[cnt].name = elf_strptr (elf, shstrndx,
shdr_info[cnt].shdr.sh_name);
INFO("\tname: %s\n", shdr_info[cnt].name);
FAILIF(shdr_info[cnt].name == NULL,
"Malformed file: section %d name is null\n",
cnt);
/* Mark them as present but not yet investigated. By "investigating"
sections, we mean that we check to see if by stripping other
sections, the sections under investigation will be compromised. For
example, if we are removing a section of code, then we want to make
sure that the symbol table does not contain symbols that refer to
this code, so we investigate the symbol table. If we do find such
symbols, we will not strip the code section.
*/
shdr_info[cnt].idx = 1;
/* Remember the shdr.sh_link value. We need to remember this value
for those sections that refer to other sections. For example,
we need to remember it for relocation-entry sections, because if
we modify the symbol table that a relocation-entry section is
relative to, then we need to patch the relocation section. By the
time we get to deciding whether we need to patch the relocation
section, we will have overwritten its header's sh_link field with
a new value.
*/
shdr_info[cnt].old_shdr = shdr_info[cnt].shdr;
INFO("\t\toriginal sh_link: %08d\n", shdr_info[cnt].old_shdr.sh_link);
INFO("\t\toriginal sh_addr: %lld\n", shdr_info[cnt].old_shdr.sh_addr);
INFO("\t\toriginal sh_offset: %lld\n",
shdr_info[cnt].old_shdr.sh_offset);
INFO("\t\toriginal sh_size: %lld\n", shdr_info[cnt].old_shdr.sh_size);
if (shdr_info[cnt].shdr.sh_type == SHT_DYNAMIC) {
INFO("\t\tthis is the SHT_DYNAMIC section [%s] at index %d\n",
shdr_info[cnt].name,
cnt);
dynamic_idx = cnt;
}
else if (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM) {
INFO("\t\tthis is the SHT_DYNSYM section [%s] at index %d\n",
shdr_info[cnt].name,
cnt);
dynsym_idx = cnt;
}
FAILIF(shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX,
"Cannot handle sh_type SHT_SYMTAB_SHNDX!\n");
FAILIF(shdr_info[cnt].shdr.sh_type == SHT_GROUP,
"Cannot handle sh_type SHT_GROUP!\n");
FAILIF(shdr_info[cnt].shdr.sh_type == SHT_GNU_versym,
"Cannot handle sh_type SHT_GNU_versym!\n");
/* Increment the counter. */
++cnt;
} /* while */
/* Get the EBL handling. */
Ebl *ebl = ebl_openbackend (elf);
FAILIF_LIBELF(NULL == ebl, ebl_openbackend);
FAILIF_LIBELF(0 != arm_init(elf, ehdr->e_machine, ebl, sizeof(Ebl)),
arm_init);
if (strip_debug) {
/* This will actually strip more than just sections. It will strip
anything not essential to running the image.
*/
INFO("Finding debug sections to strip.\n");
/* Now determine which sections can go away. The general rule is that
all sections which are not used at runtime are stripped out. But
there are a few exceptions:
- special sections named ".comment" and ".note" are kept
- OS or architecture specific sections are kept since we might not
know how to handle them
- if a section is referred to from a section which is not removed
in the sh_link or sh_info element it cannot be removed either
*/
for (cnt = 1; cnt < shnum; ++cnt) {
/* Check whether the section can be removed. */
if (SECTION_STRIP_P (ebl, elf, ehdr, &shdr_info[cnt].shdr,
shdr_info[cnt].name,
1, /* remove .comment sections */
1 /* remove all debug sections */) ||
/* The macro above is broken--check for .comment explicitly */
!strcmp(".comment", shdr_info[cnt].name)
#ifdef ARM_SPECIFIC_HACKS
||
/* We ignore this section, that's why we can remove it. */
!strcmp(".stack", shdr_info[cnt].name)
#endif
)
{
/* For now assume this section will be removed. */
INFO("Section [%s] will be stripped from image.\n",
shdr_info[cnt].name);
shdr_info[cnt].idx = 0;
}
#ifdef STRIP_STATIC_SYMBOLS
else if (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB) {
/* Mark the static symbol table for removal */
INFO("Section [%s] (static symbol table) will be stripped from image.\n",
shdr_info[cnt].name);
shdr_info[cnt].idx = 0;
if (shdr_info[shdr_info[cnt].shdr.sh_link].shdr.sh_type ==
SHT_STRTAB)
{
/* Mark the symbol table's string table for removal. */
INFO("Section [%s] (static symbol-string table) will be stripped from image.\n",
shdr_info[shdr_info[cnt].shdr.sh_link].name);
shdr_info[shdr_info[cnt].shdr.sh_link].idx = 0;
}
else {
ERROR("Expecting the sh_link field of a symbol table to point to"
" associated symbol-strings table! This is not mandated by"
" the standard, but is a common practice and the only way "
" to know for sure which strings table corresponds to which"
" symbol table!\n");
}
}
#endif
}
/* Mark the SHT_NULL section as handled. */
shdr_info[0].idx = 2;
/* Handle exceptions: section groups and cross-references. We might have
to repeat this a few times since the resetting of the flag might
propagate.
*/
int exceptions_pass = 0;
bool changes;
do {
changes = false;
INFO("\nHandling exceptions, pass %d\n\n", exceptions_pass++);
for (cnt = 1; cnt < shnum; ++cnt) {
if (shdr_info[cnt].idx == 0) {
/* If a relocation section is marked as being removed but the
section it is relocating is not, then do not remove the
relocation section.
*/
if ((shdr_info[cnt].shdr.sh_type == SHT_REL
|| shdr_info[cnt].shdr.sh_type == SHT_RELA)
&& shdr_info[shdr_info[cnt].shdr.sh_info].idx != 0) {
PRINT("\tSection [%s] will not be removed because the "
"section it is relocating (%s) stays.\n",
shdr_info[cnt].name,
shdr_info[shdr_info[cnt].shdr.sh_info].name);
}
}
if (shdr_info[cnt].idx == 1) {
INFO("Processing section [%s]...\n", shdr_info[cnt].name);
/* The content of symbol tables we don't remove must not
reference any section which we do remove. Otherwise
we cannot remove the referred section.
*/
if (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM ||
shdr_info[cnt].shdr.sh_type == SHT_SYMTAB)
{
Elf_Data *symdata;
size_t elsize;
INFO("\tSection [%s] is a symbol table that's not being"
" removed.\n\tChecking to make sure that no symbols"
" refer to sections that are being removed.\n",
shdr_info[cnt].name);
/* Make sure the data is loaded. */
symdata = elf_getdata (shdr_info[cnt].scn, NULL);
FAILIF_LIBELF(NULL == symdata, elf_getdata);
/* Go through all symbols and make sure the section they
reference is not removed. */
elsize = gelf_fsize (elf, ELF_T_SYM, 1, ehdr->e_version);
/* Check the length of the dynamic-symbol filter. */
FAILIF(sym_filter != NULL &&
(size_t)num_symbols != symdata->d_size / elsize,
"Length of dynsym filter (%d) must equal the number"
" of dynamic symbols (%zd)!\n",
num_symbols,
symdata->d_size / elsize);
size_t inner;
for (inner = 0;
inner < symdata->d_size / elsize;
++inner)
{
GElf_Sym sym_mem;
GElf_Sym *sym;
size_t scnidx;
sym = gelf_getsymshndx (symdata, NULL,
inner, &sym_mem, NULL);
FAILIF_LIBELF(sym == NULL, gelf_getsymshndx);
scnidx = sym->st_shndx;
FAILIF(scnidx == SHN_XINDEX,
"Can't handle SHN_XINDEX!\n");
if (scnidx == SHN_UNDEF ||
scnidx >= shnum ||
(scnidx >= SHN_LORESERVE &&
scnidx <= SHN_HIRESERVE) ||
GELF_ST_TYPE (sym->st_info) == STT_SECTION)
{
continue;
}
/* If the symbol is going to be thrown and it is a
global or weak symbol that is defined (not imported),
then continue. Since the symbol is going away, we
do not care whether it refers to a section that is
also going away.
*/
if (sym_filter && !sym_filter[inner])
{
bool global_or_weak =
ELF32_ST_BIND(sym->st_info) == STB_GLOBAL ||
ELF32_ST_BIND(sym->st_info) == STB_WEAK;
if (!global_or_weak && sym->st_shndx != SHN_UNDEF)
continue;
}
/* -- far too much output
INFO("\t\t\tSymbol [%s] (%d)\n",
elf_strptr(elf,
shdr_info[cnt].shdr.sh_link,
sym->st_name),
shdr_info[cnt].shdr.sh_info);
*/
if (shdr_info[scnidx].idx == 0)
{
PRINT("\t\t\tSymbol [%s] refers to section [%s], "
"which is being removed. Will keep that "
"section.\n",
elf_strptr(elf,
shdr_info[cnt].shdr.sh_link,
sym->st_name),
shdr_info[scnidx].name);
/* Mark this section as used. */
shdr_info[scnidx].idx = 1;
changes |= scnidx < cnt;
}
} /* for each symbol */
} /* section type is SHT_DYNSYM or SHT_SYMTAB */
/* Cross referencing happens:
- for the cases the ELF specification says. That are
+ SHT_DYNAMIC in sh_link to string table
+ SHT_HASH in sh_link to symbol table
+ SHT_REL and SHT_RELA in sh_link to symbol table
+ SHT_SYMTAB and SHT_DYNSYM in sh_link to string table
+ SHT_GROUP in sh_link to symbol table
+ SHT_SYMTAB_SHNDX in sh_link to symbol table
Other (OS or architecture-specific) sections might as
well use this field so we process it unconditionally.
- references inside section groups
- specially marked references in sh_info if the SHF_INFO_LINK
flag is set
*/
if (shdr_info[shdr_info[cnt].shdr.sh_link].idx == 0) {
shdr_info[shdr_info[cnt].shdr.sh_link].idx = 1;
changes |= shdr_info[cnt].shdr.sh_link < cnt;
}
/* Handle references through sh_info. */
if (SH_INFO_LINK_P (&shdr_info[cnt].shdr) &&
shdr_info[shdr_info[cnt].shdr.sh_info].idx == 0) {
PRINT("\tSection [%s] links to section [%s], which was "
"marked for removal--it will not be removed.\n",
shdr_info[cnt].name,
shdr_info[shdr_info[cnt].shdr.sh_info].name);
shdr_info[shdr_info[cnt].shdr.sh_info].idx = 1;
changes |= shdr_info[cnt].shdr.sh_info < cnt;
}
/* Mark the section as investigated. */
shdr_info[cnt].idx = 2;
} /* if (shdr_info[cnt].idx == 1) */
} /* for (cnt = 1; cnt < shnum; ++cnt) */
} while (changes);
}
else {
INFO("Not stripping sections.\n");
/* Mark the SHT_NULL section as handled. */
shdr_info[0].idx = 2;
}
/* Mark the section header string table as unused, we will create
a new one as the very last section in the new ELF file.
*/
shdr_info[shstrndx].idx = rebuild_shstrtab ? 0 : 2;
/* We need a string table for the section headers. */
FAILIF_LIBELF((shst = ebl_strtabinit (1 /* null-terminated */)) == NULL,
ebl_strtabinit);
/* Assign new section numbers. */
INFO("Creating new sections...\n");
//shdr_info[0].idx = 0;
for (cnt = idx = 1; cnt < shnum; ++cnt) {
if (shdr_info[cnt].idx > 0) {
shdr_info[cnt].idx = idx++;
/* Create a new section. */
FAILIF_LIBELF((shdr_info[cnt].newscn =
elf_newscn(newelf)) == NULL, elf_newscn);
ASSERT(elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
/* Add this name to the section header string table. */
shdr_info[cnt].se = ebl_strtabadd (shst, shdr_info[cnt].name, 0);
INFO("\tsection [%s] (old offset %lld, old size %lld) will have index %d "
"(was %zd).\n",
shdr_info[cnt].name,
shdr_info[cnt].old_shdr.sh_offset,
shdr_info[cnt].old_shdr.sh_size,
shdr_info[cnt].idx,
elf_ndxscn(shdr_info[cnt].scn));
} else {
INFO("\tIgnoring section [%s] (offset %lld, size %lld, index %zd), "
"it will be discarded.\n",
shdr_info[cnt].name,
shdr_info[cnt].shdr.sh_offset,
shdr_info[cnt].shdr.sh_size,
elf_ndxscn(shdr_info[cnt].scn));
}
} /* for */
sections_dropped_or_rearranged = idx != cnt;
Elf_Data *shstrtab_data = NULL;
#if 0
/* Fail if sections are being dropped or rearranged (except for moving shstrtab) or the
symbol filter is not empty, AND the file is an executable.
*/
FAILIF(((idx != cnt && !(cnt - idx == 1 && rebuild_shstrtab)) || sym_filter != NULL) &&
ehdr->e_type != ET_DYN,
"You may not rearrange sections or strip symbols on an executable file!\n");
#endif
INFO("\n\nADJUSTING ELF FILE\n\n");
adjust_elf(elf, elf_name,
newelf, newelf_name,
ebl,
ehdr, /* store ELF header of original library */
sym_filter, num_symbols,
shdr_info, shdr_info_len,
phdr_info,
idx, /* highest_scn_num */
shnum,
shstrndx,
shst,
sections_dropped_or_rearranged,
dynamic_idx, /* index in shdr_info[] of .dynamic section */
dynsym_idx, /* index in shdr_info[] of dynamic symbol table */
shady,
&shstrtab_data,
ehdr->e_type == ET_DYN, /* adjust section ofsets only when the file is a shared library */
rebuild_shstrtab);
/* We have everything from the old file. */
FAILIF_LIBELF(elf_cntl(elf, ELF_C_FDDONE) != 0, elf_cntl);
/* The ELF library better follows our layout when this is not a
relocatable object file. */
elf_flagelf (newelf,
ELF_C_SET,
(ehdr->e_type != ET_REL ? ELF_F_LAYOUT : 0));
/* Finally write the file. */
FAILIF_LIBELF(!dry_run && elf_update(newelf, ELF_C_WRITE) == -1, elf_update);
if (shdr_info != NULL) {
/* For some sections we might have created an table to map symbol
table indices. */
for (cnt = 1; cnt < shdr_info_len; ++cnt) {
FREEIF(shdr_info[cnt].newsymidx);
FREEIF(shdr_info[cnt].symse);
if(shdr_info[cnt].dynsymst != NULL)
ebl_strtabfree (shdr_info[cnt].dynsymst);
}
/* Free the memory. */
FREE (shdr_info);
}
FREEIF(phdr_info);
ebl_closebackend(ebl);
/* Free other resources. */
if (shst != NULL) ebl_strtabfree (shst);
if (shstrtab_data != NULL)
FREEIF(shstrtab_data->d_buf);
}
int
main(int argc, char **argv)
{
int c, ndx;
int readonly;
int fd;
const char *file;
const char *runpath;
Elf *elf;
GElf_Ehdr ehdr;
size_t shstrndx, shnum;
Elf_Scn *scn;
Elf_Data *data;
char *shnames = NULL;
Cache *cache, *_cache;
Cache *dynsec, *strsec;
GElf_Word numdyn;
dyn_elt_t rpath_elt;
dyn_elt_t runpath_elt;
dyn_elt_t strpad_elt;
dyn_elt_t flags_1_elt;
dyn_elt_t null_elt;
int changed = 0;
opterr = 0;
while ((c = getopt(argc, argv, "dr")) != EOF) {
switch (c) {
case 'd':
d_flg = 1;
break;
case 'r':
r_flg = 1;
break;
case '?':
msg_usage();
}
}
/*
* The first plain argument is the file name, and is required.
* The second plain argument is the runpath, and is optional.
* If no runpath is given, we print the current runpath to stdout
* and exit. If it is present, we modify the ELF file to use it.
*/
argc = argc - optind;
argv += optind;
if ((argc < 1) || (argc > 2))
msg_usage();
if ((argc == 2) && r_flg)
msg_usage();
readonly = (argc == 1) && !r_flg;
file = argv[0];
if (!readonly)
runpath = argv[1];
if ((fd = open(file, readonly ? O_RDONLY : O_RDWR)) == -1)
msg_fatal("unable to open file: %s: %s\n",
file, strerror(errno));
(void) elf_version(EV_CURRENT);
elf = elf_begin(fd, readonly ? ELF_C_READ : ELF_C_RDWR, NULL);
if (elf == NULL)
msg_elf("elf_begin");
/* We only handle standalone ELF files */
switch (elf_kind(elf)) {
case ELF_K_AR:
msg_fatal("unable to edit ELF archive: %s\n", file);
break;
case ELF_K_ELF:
break;
default:
msg_fatal("unable to edit non-ELF file: %s\n", file);
break;
}
if (gelf_getehdr(elf, &ehdr) == NULL)
msg_elf("gelf_getehdr");
if (elf_getshnum(elf, &shnum) == 0)
msg_elf("elf_getshnum");
if (elf_getshstrndx(elf, &shstrndx) == 0)
msg_elf("elf_getshstrndx");
/*
* Obtain the .shstrtab data buffer to provide the required section
* name strings.
*/
if ((scn = elf_getscn(elf, shstrndx)) == NULL)
msg_elf("elf_getscn");
if ((data = elf_getdata(scn, NULL)) == NULL)
msg_elf("elf_getdata");
shnames = data->d_buf;
/*
* Allocate a cache to maintain a descriptor for each section.
*/
if ((cache = malloc(shnum * sizeof (Cache))) == NULL)
msg_fatal("unable to allocate section cache: %s\n",
strerror(errno));
bzero(cache, sizeof (cache[0]));
cache->c_name = "";
_cache = cache + 1;
/*
* Fill in cache with information for each section, and
* locate the dynamic section.
*/
dynsec = strsec = NULL;
for (ndx = 1, scn = NULL; scn = elf_nextscn(elf, scn);
ndx++, _cache++) {
_cache->c_ndx = ndx;
if (gelf_getshdr(scn, &_cache->c_shdr) == NULL)
msg_elf("gelf_getshdr");
_cache->c_data = elf_getdata(scn, NULL);
_cache->c_name = shnames + _cache->c_shdr.sh_name;
if (_cache->c_shdr.sh_type == SHT_DYNAMIC) {
dynsec = _cache;
numdyn = dynsec->c_shdr.sh_size /
dynsec->c_shdr.sh_entsize;
msg_debug("[%d]%s: dynamic section\n",
ndx, _cache->c_name);
}
}
/*
* If we got a dynamic section, locate the string table.
* If not, we can't continue.
*/
if (dynsec == NULL)
msg_fatal("file lacks a dynamic section: %s\n", file);
strsec = &cache[dynsec->c_shdr.sh_link];
msg_debug("[%d]%s: dynamic string table section\n",
strsec->c_ndx, strsec->c_name);
/*
* History Lesson And Strategy:
*
* This routine handles both DT_RPATH and DT_RUNPATH entries, altering
* either or both if they are present.
*
* The original SYSV ABI only had DT_RPATH, and the runtime loader used
* it to search for things in the following order:
*
* DT_RPATH, LD_LIBRARY_PATH, defaults
*
* Solaris did not follow this rule. Environment variables should
* supersede everything else, so we have always deviated from the
* ABI and and instead search in the order
*
* LD_LIBRARY_PATH, DT_RPATH, defaults
*
* Other Unix variants initially followed the ABI, but in recent years
* realized that it was a mistake. Hence, DT_RUNPATH was invented,
* with the search order:
*
* LD_LIBRARY_PATH, DT_RUNPATH, defaults
*
* So for Solaris, DT_RPATH and DT_RUNPATH mean the same thing. If both
* are present (which does happen), we set them both to the new
* value. If either one is present, we set that one. If neither is
* present, and we have a spare DT_NULL slot, we create a DT_RUNPATH.
*/
/*
* Examine the dynamic section to determine the index for
* - DT_RPATH
* - DT_RUNPATH
* - DT_SUNW_STRPAD
* - DT_NULL, and whether there are any extra DT_NULL slots
*/
dyn_elt_init(&rpath_elt);
dyn_elt_init(&runpath_elt);
dyn_elt_init(&strpad_elt);
dyn_elt_init(&flags_1_elt);
dyn_elt_init(&null_elt);
for (ndx = 0; ndx < numdyn; ndx++) {
GElf_Dyn dyn;
if (gelf_getdyn(dynsec->c_data, ndx, &dyn) == NULL)
msg_elf("gelf_getdyn");
switch (dyn.d_tag) {
case DT_NULL:
/*
* Remember the state of the first DT_NULL. If there
* are more than one (i.e. the first one is not
* in the final spot), and there is no runpath, then
* we will turn the first one into a DT_RUNPATH.
*/
if (!null_elt.seen) {
dyn_elt_save(&null_elt, ndx, &dyn);
msg_debug("[%d]%s[%d]: DT_NULL\n",
dynsec->c_ndx, dynsec->c_name, ndx);
}
break;
case DT_RPATH:
dyn_elt_save(&rpath_elt, ndx, &dyn);
msg_debug("[%d]%s[%d]: DT_RPATH: %s\n",
dynsec->c_ndx, dynsec->c_name, ndx,
DYN_ELT_STRING(&rpath_elt, strsec));
break;
case DT_RUNPATH:
dyn_elt_save(&runpath_elt, ndx, &dyn);
msg_debug("[%d]%s[%d]: DT_RUNPATH: %s\n",
dynsec->c_ndx, dynsec->c_name, ndx,
DYN_ELT_STRING(&runpath_elt, strsec));
break;
case DT_SUNW_STRPAD:
dyn_elt_save(&strpad_elt, ndx, &dyn);
msg_debug("[%d]%s[%d]: DT_STRPAD: %d\n",
dynsec->c_ndx, dynsec->c_name, ndx,
(int)strpad_elt.dyn.d_un.d_val);
break;
case DT_FLAGS_1:
dyn_elt_save(&flags_1_elt, ndx, &dyn);
break;
}
}
/*
* If this is a readonly session, then print the existing
* runpath and exit. DT_RPATH and DT_RUNPATH should have
* the same value, so we arbitrarily favor DT_RUNPATH.
*/
if (readonly) {
if (runpath_elt.seen)
(void) printf("%s\n",
DYN_ELT_STRING(&runpath_elt, strsec));
else if (rpath_elt.seen)
(void) printf("%s\n",
DYN_ELT_STRING(&rpath_elt, strsec));
else
msg_debug("ELF file does not have a runpath: %s\n",
file);
return (0);
}
/* Edit the file, either to remove the runpath or to add/modify it */
if (r_flg) {
if (!(runpath_elt.seen || rpath_elt.seen))
msg_debug("[%d]%s: no runpath found\n",
dynsec->c_ndx, dynsec->c_name);
else
changed = remove_runpath(dynsec, numdyn);
} else {
changed = new_runpath(runpath, dynsec, numdyn, strsec,
&rpath_elt, &runpath_elt, &strpad_elt, &null_elt);
}
if (changed) {
/*
* If possible, set the DF_1_EDITED flag, indicating that
* this file has been edited after the fact.
*/
if (flags_1_elt.seen) {
flags_1_elt.dyn.d_un.d_val |= DF_1_EDITED;
} else if (null_elt.seen && (null_elt.ndx < (numdyn - 1))) {
msg_debug("[%d]%s: No existing flags_1 entry to "
"modify. Will use extra DT_NULL in slot [%d] \n",
dynsec->c_ndx, dynsec->c_name, null_elt.ndx);
flags_1_elt.seen = 1;
flags_1_elt.ndx = null_elt.ndx;
flags_1_elt.dyn.d_tag = DT_FLAGS_1;
flags_1_elt.dyn.d_un.d_val = DF_1_EDITED;
}
if (flags_1_elt.seen) {
msg_debug("[%d]%s[%d]: Set DF_1_EDITED flag\n",
dynsec->c_ndx, dynsec->c_name, flags_1_elt.ndx);
if (gelf_update_dyn(dynsec->c_data, flags_1_elt.ndx,
&flags_1_elt.dyn) == 0)
msg_elf("gelf_update_dyn");
}
/*
* Mark the data area as dirty so libelf will flush our
* changes to the dynamic section data.
*/
(void) elf_flagdata(dynsec->c_data, ELF_C_SET, ELF_F_DIRTY);
/* Flush the file to disk */
if (elf_update(elf, ELF_C_WRITE) == -1)
msg_elf("elf_update");
(void) close(fd);
(void) elf_end(elf);
}
return (0);
}
void
pmcstat_image_get_elf_params(struct pmcstat_image *image,
struct pmcstat_args *args)
{
int fd;
size_t i, nph, nsh;
const char *path, *elfbase;
char *p, *endp;
uintfptr_t minva, maxva;
Elf *e;
Elf_Scn *scn;
GElf_Ehdr eh;
GElf_Phdr ph;
GElf_Shdr sh;
enum pmcstat_image_type image_type;
char buffer[PATH_MAX];
assert(image->pi_type == PMCSTAT_IMAGE_UNKNOWN);
image->pi_start = minva = ~(uintfptr_t) 0;
image->pi_end = maxva = (uintfptr_t) 0;
image->pi_type = image_type = PMCSTAT_IMAGE_INDETERMINABLE;
image->pi_isdynamic = 0;
image->pi_dynlinkerpath = NULL;
image->pi_vaddr = 0;
path = pmcstat_string_unintern(image->pi_execpath);
assert(path != NULL);
/*
* Look for kernel modules under FSROOT/KERNELPATH/NAME,
* and user mode executable objects under FSROOT/PATHNAME.
*/
if (image->pi_iskernelmodule)
(void) snprintf(buffer, sizeof(buffer), "%s%s/%s",
args->pa_fsroot, args->pa_kernel, path);
else
(void) snprintf(buffer, sizeof(buffer), "%s%s",
args->pa_fsroot, path);
e = NULL;
if ((fd = open(buffer, O_RDONLY, 0)) < 0) {
warnx("WARNING: Cannot open \"%s\".",
buffer);
goto done;
}
if (elf_version(EV_CURRENT) == EV_NONE) {
warnx("WARNING: failed to init elf\n");
goto done;
}
if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
warnx("WARNING: Cannot read \"%s\".",
buffer);
goto done;
}
if (elf_kind(e) != ELF_K_ELF) {
if (args->pa_verbosity >= 2)
warnx("WARNING: Cannot determine the type of \"%s\".",
buffer);
goto done;
}
if (gelf_getehdr(e, &eh) != &eh) {
warnx(
"WARNING: Cannot retrieve the ELF Header for \"%s\": %s.",
buffer, elf_errmsg(-1));
goto done;
}
if (eh.e_type != ET_EXEC && eh.e_type != ET_DYN &&
!(image->pi_iskernelmodule && eh.e_type == ET_REL)) {
warnx("WARNING: \"%s\" is of an unsupported ELF type.",
buffer);
goto done;
}
image_type = eh.e_ident[EI_CLASS] == ELFCLASS32 ?
PMCSTAT_IMAGE_ELF32 : PMCSTAT_IMAGE_ELF64;
/*
* Determine the virtual address where an executable would be
* loaded. Additionally, for dynamically linked executables,
* save the pathname to the runtime linker.
*/
if (eh.e_type == ET_EXEC) {
if (elf_getphnum(e, &nph) == 0) {
warnx(
"WARNING: Could not determine the number of program headers in \"%s\": %s.",
buffer,
elf_errmsg(-1));
goto done;
}
for (i = 0; i < eh.e_phnum; i++) {
if (gelf_getphdr(e, i, &ph) != &ph) {
warnx(
"WARNING: Retrieval of PHDR entry #%ju in \"%s\" failed: %s.",
(uintmax_t) i, buffer, elf_errmsg(-1));
goto done;
}
switch (ph.p_type) {
case PT_DYNAMIC:
image->pi_isdynamic = 1;
break;
case PT_INTERP:
if ((elfbase = elf_rawfile(e, NULL)) == NULL) {
warnx(
"WARNING: Cannot retrieve the interpreter for \"%s\": %s.",
buffer, elf_errmsg(-1));
goto done;
}
image->pi_dynlinkerpath =
pmcstat_string_intern(elfbase +
ph.p_offset);
break;
case PT_LOAD:
if ((ph.p_flags & PF_X) != 0 &&
(ph.p_offset & (-ph.p_align)) == 0)
image->pi_vaddr = ph.p_vaddr & (-ph.p_align);
break;
}
}
}
/*
* Get the min and max VA associated with this ELF object.
*/
if (elf_getshnum(e, &nsh) == 0) {
warnx(
"WARNING: Could not determine the number of sections for \"%s\": %s.",
buffer, elf_errmsg(-1));
goto done;
}
for (i = 0; i < nsh; i++) {
if ((scn = elf_getscn(e, i)) == NULL ||
gelf_getshdr(scn, &sh) != &sh) {
warnx(
"WARNING: Could not retrieve section header #%ju in \"%s\": %s.",
(uintmax_t) i, buffer, elf_errmsg(-1));
goto done;
}
if (sh.sh_flags & SHF_EXECINSTR) {
minva = min(minva, sh.sh_addr);
maxva = max(maxva, sh.sh_addr + sh.sh_size);
}
if (sh.sh_type == SHT_SYMTAB || sh.sh_type == SHT_DYNSYM)
pmcstat_image_add_symbols(image, e, scn, &sh);
}
image->pi_start = minva;
image->pi_end = maxva;
image->pi_type = image_type;
image->pi_fullpath = pmcstat_string_intern(buffer);
/* Build display name
*/
endp = buffer;
for (p = buffer; *p; p++)
if (*p == '/')
endp = p+1;
image->pi_name = pmcstat_string_intern(endp);
done:
(void) elf_end(e);
if (fd >= 0)
(void) close(fd);
return;
}
