dump: Add architecture section and section string table support

Add hooks which architectures can use to add arbitrary data to custom
sections.

Also add a section name string table in order to identify section
contents

Signed-off-by: Janosch Frank <frankja@linux.ibm.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <20221017113210.41674-1-frankja@linux.ibm.com>
This commit is contained in:
Janosch Frank 2022-10-17 11:32:10 +00:00 committed by Marc-André Lureau
parent 13fd417ddc
commit 9b72224f44
3 changed files with 168 additions and 28 deletions

View File

@ -103,6 +103,7 @@ static int dump_cleanup(DumpState *s)
memory_mapping_list_free(&s->list); memory_mapping_list_free(&s->list);
close(s->fd); close(s->fd);
g_free(s->guest_note); g_free(s->guest_note);
g_array_unref(s->string_table_buf);
s->guest_note = NULL; s->guest_note = NULL;
if (s->resume) { if (s->resume) {
if (s->detached) { if (s->detached) {
@ -152,11 +153,10 @@ static void prepare_elf64_header(DumpState *s, Elf64_Ehdr *elf_header)
elf_header->e_phoff = cpu_to_dump64(s, s->phdr_offset); elf_header->e_phoff = cpu_to_dump64(s, s->phdr_offset);
elf_header->e_phentsize = cpu_to_dump16(s, sizeof(Elf64_Phdr)); elf_header->e_phentsize = cpu_to_dump16(s, sizeof(Elf64_Phdr));
elf_header->e_phnum = cpu_to_dump16(s, phnum); elf_header->e_phnum = cpu_to_dump16(s, phnum);
if (s->shdr_num) { elf_header->e_shoff = cpu_to_dump64(s, s->shdr_offset);
elf_header->e_shoff = cpu_to_dump64(s, s->shdr_offset); elf_header->e_shentsize = cpu_to_dump16(s, sizeof(Elf64_Shdr));
elf_header->e_shentsize = cpu_to_dump16(s, sizeof(Elf64_Shdr)); elf_header->e_shnum = cpu_to_dump16(s, s->shdr_num);
elf_header->e_shnum = cpu_to_dump16(s, s->shdr_num); elf_header->e_shstrndx = cpu_to_dump16(s, s->shdr_num - 1);
}
} }
static void prepare_elf32_header(DumpState *s, Elf32_Ehdr *elf_header) static void prepare_elf32_header(DumpState *s, Elf32_Ehdr *elf_header)
@ -180,11 +180,10 @@ static void prepare_elf32_header(DumpState *s, Elf32_Ehdr *elf_header)
elf_header->e_phoff = cpu_to_dump32(s, s->phdr_offset); elf_header->e_phoff = cpu_to_dump32(s, s->phdr_offset);
elf_header->e_phentsize = cpu_to_dump16(s, sizeof(Elf32_Phdr)); elf_header->e_phentsize = cpu_to_dump16(s, sizeof(Elf32_Phdr));
elf_header->e_phnum = cpu_to_dump16(s, phnum); elf_header->e_phnum = cpu_to_dump16(s, phnum);
if (s->shdr_num) { elf_header->e_shoff = cpu_to_dump32(s, s->shdr_offset);
elf_header->e_shoff = cpu_to_dump32(s, s->shdr_offset); elf_header->e_shentsize = cpu_to_dump16(s, sizeof(Elf32_Shdr));
elf_header->e_shentsize = cpu_to_dump16(s, sizeof(Elf32_Shdr)); elf_header->e_shnum = cpu_to_dump16(s, s->shdr_num);
elf_header->e_shnum = cpu_to_dump16(s, s->shdr_num); elf_header->e_shstrndx = cpu_to_dump16(s, s->shdr_num - 1);
}
} }
static void write_elf_header(DumpState *s, Error **errp) static void write_elf_header(DumpState *s, Error **errp)
@ -195,6 +194,8 @@ static void write_elf_header(DumpState *s, Error **errp)
void *header_ptr; void *header_ptr;
int ret; int ret;
/* The NULL header and the shstrtab are always defined */
assert(s->shdr_num >= 2);
if (dump_is_64bit(s)) { if (dump_is_64bit(s)) {
prepare_elf64_header(s, &elf64_header); prepare_elf64_header(s, &elf64_header);
header_size = sizeof(elf64_header); header_size = sizeof(elf64_header);
@ -393,17 +394,49 @@ static void prepare_elf_section_hdr_zero(DumpState *s)
} }
} }
static void prepare_elf_section_hdrs(DumpState *s) static void prepare_elf_section_hdr_string(DumpState *s, void *buff)
{
uint64_t index = s->string_table_buf->len;
const char strtab[] = ".shstrtab";
Elf32_Shdr shdr32 = {};
Elf64_Shdr shdr64 = {};
int shdr_size;
void *shdr;
g_array_append_vals(s->string_table_buf, strtab, sizeof(strtab));
if (dump_is_64bit(s)) {
shdr_size = sizeof(Elf64_Shdr);
shdr64.sh_type = SHT_STRTAB;
shdr64.sh_offset = s->section_offset + s->elf_section_data_size;
shdr64.sh_name = index;
shdr64.sh_size = s->string_table_buf->len;
shdr = &shdr64;
} else {
shdr_size = sizeof(Elf32_Shdr);
shdr32.sh_type = SHT_STRTAB;
shdr32.sh_offset = s->section_offset + s->elf_section_data_size;
shdr32.sh_name = index;
shdr32.sh_size = s->string_table_buf->len;
shdr = &shdr32;
}
memcpy(buff, shdr, shdr_size);
}
static bool prepare_elf_section_hdrs(DumpState *s, Error **errp)
{ {
size_t len, sizeof_shdr; size_t len, sizeof_shdr;
void *buff_hdr;
/* /*
* Section ordering: * Section ordering:
* - HDR zero * - HDR zero
* - Arch section hdrs
* - String table hdr
*/ */
sizeof_shdr = dump_is_64bit(s) ? sizeof(Elf64_Shdr) : sizeof(Elf32_Shdr); sizeof_shdr = dump_is_64bit(s) ? sizeof(Elf64_Shdr) : sizeof(Elf32_Shdr);
len = sizeof_shdr * s->shdr_num; len = sizeof_shdr * s->shdr_num;
s->elf_section_hdrs = g_malloc0(len); s->elf_section_hdrs = g_malloc0(len);
buff_hdr = s->elf_section_hdrs;
/* /*
* The first section header is ALWAYS a special initial section * The first section header is ALWAYS a special initial section
@ -419,6 +452,26 @@ static void prepare_elf_section_hdrs(DumpState *s)
if (s->phdr_num >= PN_XNUM) { if (s->phdr_num >= PN_XNUM) {
prepare_elf_section_hdr_zero(s); prepare_elf_section_hdr_zero(s);
} }
buff_hdr += sizeof_shdr;
/* Add architecture defined section headers */
if (s->dump_info.arch_sections_write_hdr_fn
&& s->shdr_num > 2) {
buff_hdr += s->dump_info.arch_sections_write_hdr_fn(s, buff_hdr);
if (s->shdr_num >= SHN_LORESERVE) {
error_setg_errno(errp, EINVAL,
"dump: too many architecture defined sections");
return false;
}
}
/*
* String table is the last section since strings are added via
* arch_sections_write_hdr().
*/
prepare_elf_section_hdr_string(s, buff_hdr);
return true;
} }
static void write_elf_section_headers(DumpState *s, Error **errp) static void write_elf_section_headers(DumpState *s, Error **errp)
@ -426,7 +479,9 @@ static void write_elf_section_headers(DumpState *s, Error **errp)
size_t sizeof_shdr = dump_is_64bit(s) ? sizeof(Elf64_Shdr) : sizeof(Elf32_Shdr); size_t sizeof_shdr = dump_is_64bit(s) ? sizeof(Elf64_Shdr) : sizeof(Elf32_Shdr);
int ret; int ret;
prepare_elf_section_hdrs(s); if (!prepare_elf_section_hdrs(s, errp)) {
return;
}
ret = fd_write_vmcore(s->elf_section_hdrs, s->shdr_num * sizeof_shdr, s); ret = fd_write_vmcore(s->elf_section_hdrs, s->shdr_num * sizeof_shdr, s);
if (ret < 0) { if (ret < 0) {
@ -436,6 +491,29 @@ static void write_elf_section_headers(DumpState *s, Error **errp)
g_free(s->elf_section_hdrs); g_free(s->elf_section_hdrs);
} }
static void write_elf_sections(DumpState *s, Error **errp)
{
int ret;
if (s->elf_section_data_size) {
/* Write architecture section data */
ret = fd_write_vmcore(s->elf_section_data,
s->elf_section_data_size, s);
if (ret < 0) {
error_setg_errno(errp, -ret,
"dump: failed to write architecture section data");
return;
}
}
/* Write string table */
ret = fd_write_vmcore(s->string_table_buf->data,
s->string_table_buf->len, s);
if (ret < 0) {
error_setg_errno(errp, -ret, "dump: failed to write string table data");
}
}
static void write_data(DumpState *s, void *buf, int length, Error **errp) static void write_data(DumpState *s, void *buf, int length, Error **errp)
{ {
int ret; int ret;
@ -692,6 +770,31 @@ static void dump_iterate(DumpState *s, Error **errp)
} }
} }
static void dump_end(DumpState *s, Error **errp)
{
int rc;
ERRP_GUARD();
if (s->elf_section_data_size) {
s->elf_section_data = g_malloc0(s->elf_section_data_size);
}
/* Adds the architecture defined section data to s->elf_section_data */
if (s->dump_info.arch_sections_write_fn &&
s->elf_section_data_size) {
rc = s->dump_info.arch_sections_write_fn(s, s->elf_section_data);
if (rc) {
error_setg_errno(errp, rc,
"dump: failed to get arch section data");
g_free(s->elf_section_data);
return;
}
}
/* write sections to vmcore */
write_elf_sections(s, errp);
}
static void create_vmcore(DumpState *s, Error **errp) static void create_vmcore(DumpState *s, Error **errp)
{ {
ERRP_GUARD(); ERRP_GUARD();
@ -701,7 +804,14 @@ static void create_vmcore(DumpState *s, Error **errp)
return; return;
} }
/* Iterate over memory and dump it to file */
dump_iterate(s, errp); dump_iterate(s, errp);
if (*errp) {
return;
}
/* Write the section data */
dump_end(s, errp);
} }
static int write_start_flat_header(int fd) static int write_start_flat_header(int fd)
@ -1711,6 +1821,14 @@ static void dump_init(DumpState *s, int fd, bool has_format,
s->filter_area_begin = begin; s->filter_area_begin = begin;
s->filter_area_length = length; s->filter_area_length = length;
/* First index is 0, it's the special null name */
s->string_table_buf = g_array_new(FALSE, TRUE, 1);
/*
* Allocate the null name, due to the clearing option set to true
* it will be 0.
*/
g_array_set_size(s->string_table_buf, 1);
memory_mapping_list_init(&s->list); memory_mapping_list_init(&s->list);
guest_phys_blocks_init(&s->guest_phys_blocks); guest_phys_blocks_init(&s->guest_phys_blocks);
@ -1847,26 +1965,42 @@ static void dump_init(DumpState *s, int fd, bool has_format,
} }
/* /*
* calculate phdr_num * The first section header is always a special one in which most
* * fields are 0. The section header string table is also always
* the type of ehdr->e_phnum is uint16_t, so we should avoid overflow * set.
*/ */
s->phdr_num = 1; /* PT_NOTE */ s->shdr_num = 2;
if (s->list.num < UINT16_MAX - 2) {
s->shdr_num = 0;
s->phdr_num += s->list.num;
} else {
/* sh_info of section 0 holds the real number of phdrs */
s->shdr_num = 1;
/* the type of shdr->sh_info is uint32_t, so we should avoid overflow */ /*
if (s->list.num <= UINT32_MAX - 1) { * Adds the number of architecture sections to shdr_num and sets
s->phdr_num += s->list.num; * elf_section_data_size so we know the offsets and sizes of all
} else { * parts.
s->phdr_num = UINT32_MAX; */
} if (s->dump_info.arch_sections_add_fn) {
s->dump_info.arch_sections_add_fn(s);
} }
/*
* calculate shdr_num so we know the offsets and sizes of all
* parts.
* Calculate phdr_num
*
* The absolute maximum amount of phdrs is UINT32_MAX - 1 as
* sh_info is 32 bit. There's special handling once we go over
* UINT16_MAX - 1 but that is handled in the ehdr and section
* code.
*/
s->phdr_num = 1; /* Reserve PT_NOTE */
if (s->list.num <= UINT32_MAX - 1) {
s->phdr_num += s->list.num;
} else {
s->phdr_num = UINT32_MAX;
}
/*
* Now that the number of section and program headers is known we
* can calculate the offsets of the headers and data.
*/
if (dump_is_64bit(s)) { if (dump_is_64bit(s)) {
s->shdr_offset = sizeof(Elf64_Ehdr); s->shdr_offset = sizeof(Elf64_Ehdr);
s->phdr_offset = s->shdr_offset + sizeof(Elf64_Shdr) * s->shdr_num; s->phdr_offset = s->shdr_offset + sizeof(Elf64_Shdr) * s->shdr_num;

View File

@ -21,6 +21,9 @@ typedef struct ArchDumpInfo {
uint32_t page_size; /* The target's page size. If it's variable and uint32_t page_size; /* The target's page size. If it's variable and
* unknown, then this should be the maximum. */ * unknown, then this should be the maximum. */
uint64_t phys_base; /* The target's physmem base. */ uint64_t phys_base; /* The target's physmem base. */
void (*arch_sections_add_fn)(DumpState *s);
uint64_t (*arch_sections_write_hdr_fn)(DumpState *s, uint8_t *buff);
int (*arch_sections_write_fn)(DumpState *s, uint8_t *buff);
} ArchDumpInfo; } ArchDumpInfo;
struct GuestPhysBlockList; /* memory_mapping.h */ struct GuestPhysBlockList; /* memory_mapping.h */

View File

@ -180,6 +180,9 @@ typedef struct DumpState {
hwaddr note_offset; hwaddr note_offset;
void *elf_section_hdrs; /* Pointer to section header buffer */ void *elf_section_hdrs; /* Pointer to section header buffer */
void *elf_section_data; /* Pointer to section data buffer */
uint64_t elf_section_data_size; /* Size of section data */
GArray *string_table_buf; /* String table data buffer */
uint8_t *note_buf; /* buffer for notes */ uint8_t *note_buf; /* buffer for notes */
size_t note_buf_offset; /* the writing place in note_buf */ size_t note_buf_offset; /* the writing place in note_buf */