diff options
Diffstat (limited to 'util_lib/elf_info.c')
| -rw-r--r-- | util_lib/elf_info.c | 1284 |
1 files changed, 1284 insertions, 0 deletions
diff --git a/util_lib/elf_info.c b/util_lib/elf_info.c new file mode 100644 index 0000000..ce71c60 --- /dev/null +++ b/util_lib/elf_info.c @@ -0,0 +1,1284 @@ +/* + * elf_info.c: Architecture independent code for parsing elf files. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation (version 2 of the License). + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include <elf_info.h> + +/* The 32bit and 64bit note headers make it clear we don't care */ +typedef Elf32_Nhdr Elf_Nhdr; + +const char *fname; +static Elf64_Ehdr ehdr; +static Elf64_Phdr *phdr; +static int num_pt_loads; + +static char osrelease[4096]; + +/* VMCOREINFO symbols for lockless printk ringbuffer */ +static loff_t prb_vaddr; +static size_t printk_ringbuffer_sz; +static size_t prb_desc_sz; +static size_t printk_info_sz; +static uint64_t printk_ringbuffer_desc_ring_offset; +static uint64_t printk_ringbuffer_text_data_ring_offset; +static uint64_t prb_desc_ring_count_bits_offset; +static uint64_t prb_desc_ring_descs_offset; +static uint64_t prb_desc_ring_infos_offset; +static uint64_t prb_data_ring_size_bits_offset; +static uint64_t prb_data_ring_data_offset; +static uint64_t prb_desc_ring_head_id_offset; +static uint64_t prb_desc_ring_tail_id_offset; +static uint64_t atomic_long_t_counter_offset; +static uint64_t prb_desc_state_var_offset; +static uint64_t prb_desc_info_offset; +static uint64_t prb_desc_text_blk_lpos_offset; +static uint64_t prb_data_blk_lpos_begin_offset; +static uint64_t prb_data_blk_lpos_next_offset; +static uint64_t printk_info_seq_offset; +static uint64_t printk_info_caller_id_offset; +static uint64_t printk_info_ts_nsec_offset; +static uint64_t printk_info_level_offset; +static uint64_t printk_info_text_len_offset; + +static loff_t log_buf_vaddr; +static loff_t log_end_vaddr; +static loff_t log_buf_len_vaddr; +static loff_t logged_chars_vaddr; + +/* record format logs */ +static loff_t log_first_idx_vaddr; +static loff_t log_next_idx_vaddr; + +/* struct printk_log (or older log) size */ +static uint64_t log_sz; + +/* struct printk_log (or older log) field offsets */ +static uint64_t log_offset_ts_nsec = UINT64_MAX; +static uint16_t log_offset_len = UINT16_MAX; +static uint16_t log_offset_text_len = UINT16_MAX; + +static uint64_t phys_offset = UINT64_MAX; + +#if __BYTE_ORDER == __LITTLE_ENDIAN +#define ELFDATANATIVE ELFDATA2LSB +#elif __BYTE_ORDER == __BIG_ENDIAN +#define ELFDATANATIVE ELFDATA2MSB +#else +#error "Unknown machine endian" +#endif + +static uint16_t file16_to_cpu(uint16_t val) +{ + if (ehdr.e_ident[EI_DATA] != ELFDATANATIVE) + val = bswap_16(val); + return val; +} + +static uint32_t file32_to_cpu(uint32_t val) +{ + if (ehdr.e_ident[EI_DATA] != ELFDATANATIVE) + val = bswap_32(val); + return val; +} + +static uint64_t file64_to_cpu(uint64_t val) +{ + if (ehdr.e_ident[EI_DATA] != ELFDATANATIVE) + val = bswap_64(val); + return val; +} + +static uint64_t vaddr_to_offset(uint64_t vaddr) +{ + /* Just hand the simple case where kexec gets + * the virtual address on the program headers right. + */ + ssize_t i; + for (i = 0; i < ehdr.e_phnum; i++) { + if (phdr[i].p_vaddr > vaddr) + continue; + if ((phdr[i].p_vaddr + phdr[i].p_memsz) <= vaddr) + continue; + return (vaddr - phdr[i].p_vaddr) + phdr[i].p_offset; + } + fprintf(stderr, "No program header covering vaddr 0x%llxfound kexec bug?\n", + (unsigned long long)vaddr); + exit(30); +} + +static unsigned machine_pointer_bits(void) +{ + uint8_t bits = 0; + + /* Default to the size of the elf class */ + switch(ehdr.e_ident[EI_CLASS]) { + case ELFCLASS32: bits = 32; break; + case ELFCLASS64: bits = 64; break; + } + + /* Report the architectures pointer size */ + switch(ehdr.e_machine) { + case EM_386: bits = 32; break; + } + + return bits; +} + +void read_elf32(int fd) +{ + Elf32_Ehdr ehdr32; + Elf32_Phdr *phdr32; + size_t phdrs32_size; + ssize_t ret, i; + + ret = pread(fd, &ehdr32, sizeof(ehdr32), 0); + if (ret != sizeof(ehdr32)) { + fprintf(stderr, "Read of Elf header from %s failed: %s\n", + fname, strerror(errno)); + exit(10); + } + + ehdr.e_type = file16_to_cpu(ehdr32.e_type); + ehdr.e_machine = file16_to_cpu(ehdr32.e_machine); + ehdr.e_version = file32_to_cpu(ehdr32.e_version); + ehdr.e_entry = file32_to_cpu(ehdr32.e_entry); + ehdr.e_phoff = file32_to_cpu(ehdr32.e_phoff); + ehdr.e_shoff = file32_to_cpu(ehdr32.e_shoff); + ehdr.e_flags = file32_to_cpu(ehdr32.e_flags); + ehdr.e_ehsize = file16_to_cpu(ehdr32.e_ehsize); + ehdr.e_phentsize = file16_to_cpu(ehdr32.e_phentsize); + ehdr.e_phnum = file16_to_cpu(ehdr32.e_phnum); + ehdr.e_shentsize = file16_to_cpu(ehdr32.e_shentsize); + ehdr.e_shnum = file16_to_cpu(ehdr32.e_shnum); + ehdr.e_shstrndx = file16_to_cpu(ehdr32.e_shstrndx); + + if (ehdr.e_version != EV_CURRENT) { + fprintf(stderr, "Bad Elf header version %u\n", + ehdr.e_version); + exit(11); + } + if (ehdr.e_phentsize != sizeof(Elf32_Phdr)) { + fprintf(stderr, "Bad Elf progra header size %u expected %zu\n", + ehdr.e_phentsize, sizeof(Elf32_Phdr)); + exit(12); + } + phdrs32_size = ehdr.e_phnum * sizeof(Elf32_Phdr); + phdr32 = calloc(ehdr.e_phnum, sizeof(Elf32_Phdr)); + if (!phdr32) { + fprintf(stderr, "Calloc of %u phdrs32 failed: %s\n", + ehdr.e_phnum, strerror(errno)); + exit(14); + } + phdr = calloc(ehdr.e_phnum, sizeof(Elf64_Phdr)); + if (!phdr) { + fprintf(stderr, "Calloc of %u phdrs failed: %s\n", + ehdr.e_phnum, strerror(errno)); + exit(15); + } + ret = pread(fd, phdr32, phdrs32_size, ehdr.e_phoff); + if (ret < 0 || (size_t)ret != phdrs32_size) { + fprintf(stderr, "Read of program header @ 0x%llu for %zu bytes failed: %s\n", + (unsigned long long)ehdr.e_phoff, phdrs32_size, strerror(errno)); + exit(16); + } + for (i = 0; i < ehdr.e_phnum; i++) { + phdr[i].p_type = file32_to_cpu(phdr32[i].p_type); + phdr[i].p_offset = file32_to_cpu(phdr32[i].p_offset); + phdr[i].p_vaddr = file32_to_cpu(phdr32[i].p_vaddr); + phdr[i].p_paddr = file32_to_cpu(phdr32[i].p_paddr); + phdr[i].p_filesz = file32_to_cpu(phdr32[i].p_filesz); + phdr[i].p_memsz = file32_to_cpu(phdr32[i].p_memsz); + phdr[i].p_flags = file32_to_cpu(phdr32[i].p_flags); + phdr[i].p_align = file32_to_cpu(phdr32[i].p_align); + + if (phdr[i].p_type == PT_LOAD) + num_pt_loads++; + } + free(phdr32); +} + +void read_elf64(int fd) +{ + Elf64_Ehdr ehdr64; + Elf64_Phdr *phdr64; + size_t phdrs_size; + ssize_t ret, i; + + ret = pread(fd, &ehdr64, sizeof(ehdr64), 0); + if (ret < 0 || (size_t)ret != sizeof(ehdr)) { + fprintf(stderr, "Read of Elf header from %s failed: %s\n", + fname, strerror(errno)); + exit(10); + } + + ehdr.e_type = file16_to_cpu(ehdr64.e_type); + ehdr.e_machine = file16_to_cpu(ehdr64.e_machine); + ehdr.e_version = file32_to_cpu(ehdr64.e_version); + ehdr.e_entry = file64_to_cpu(ehdr64.e_entry); + ehdr.e_phoff = file64_to_cpu(ehdr64.e_phoff); + ehdr.e_shoff = file64_to_cpu(ehdr64.e_shoff); + ehdr.e_flags = file32_to_cpu(ehdr64.e_flags); + ehdr.e_ehsize = file16_to_cpu(ehdr64.e_ehsize); + ehdr.e_phentsize = file16_to_cpu(ehdr64.e_phentsize); + ehdr.e_phnum = file16_to_cpu(ehdr64.e_phnum); + ehdr.e_shentsize = file16_to_cpu(ehdr64.e_shentsize); + ehdr.e_shnum = file16_to_cpu(ehdr64.e_shnum); + ehdr.e_shstrndx = file16_to_cpu(ehdr64.e_shstrndx); + + if (ehdr.e_version != EV_CURRENT) { + fprintf(stderr, "Bad Elf header version %u\n", + ehdr.e_version); + exit(11); + } + if (ehdr.e_phentsize != sizeof(Elf64_Phdr)) { + fprintf(stderr, "Bad Elf progra header size %u expected %zu\n", + ehdr.e_phentsize, sizeof(Elf64_Phdr)); + exit(12); + } + phdrs_size = ehdr.e_phnum * sizeof(Elf64_Phdr); + phdr64 = calloc(ehdr.e_phnum, sizeof(Elf64_Phdr)); + if (!phdr64) { + fprintf(stderr, "Calloc of %u phdrs64 failed: %s\n", + ehdr.e_phnum, strerror(errno)); + exit(14); + } + phdr = calloc(ehdr.e_phnum, sizeof(Elf64_Phdr)); + if (!phdr) { + fprintf(stderr, "Calloc of %u phdrs failed: %s\n", + ehdr.e_phnum, strerror(errno)); + exit(15); + } + ret = pread(fd, phdr64, phdrs_size, ehdr.e_phoff); + if (ret < 0 || (size_t)ret != phdrs_size) { + fprintf(stderr, "Read of program header @ %llu for %zu bytes failed: %s\n", + (unsigned long long)(ehdr.e_phoff), phdrs_size, strerror(errno)); + exit(16); + } + for (i = 0; i < ehdr.e_phnum; i++) { + phdr[i].p_type = file32_to_cpu(phdr64[i].p_type); + phdr[i].p_flags = file32_to_cpu(phdr64[i].p_flags); + phdr[i].p_offset = file64_to_cpu(phdr64[i].p_offset); + phdr[i].p_vaddr = file64_to_cpu(phdr64[i].p_vaddr); + phdr[i].p_paddr = file64_to_cpu(phdr64[i].p_paddr); + phdr[i].p_filesz = file64_to_cpu(phdr64[i].p_filesz); + phdr[i].p_memsz = file64_to_cpu(phdr64[i].p_memsz); + phdr[i].p_align = file64_to_cpu(phdr64[i].p_align); + + if (phdr[i].p_type == PT_LOAD) + num_pt_loads++; + } + free(phdr64); +} + +int get_pt_load(int idx, + unsigned long long *phys_start, + unsigned long long *phys_end, + unsigned long long *virt_start, + unsigned long long *virt_end) +{ + Elf64_Phdr *pls; + + if (num_pt_loads <= idx) + return 0; + + pls = &phdr[idx]; + + if (phys_start) + *phys_start = pls->p_paddr; + if (phys_end) + *phys_end = pls->p_paddr + pls->p_memsz; + if (virt_start) + *virt_start = pls->p_vaddr; + if (virt_end) + *virt_end = pls->p_vaddr + pls->p_memsz; + + return 1; +} + +#define NOT_FOUND_LONG_VALUE (-1) + +void (*arch_scan_vmcoreinfo)(char *pos); + +void scan_vmcoreinfo(char *start, size_t size) +{ + char *last = start + size - 1; + char *pos, *eol; + char temp_buf[1024]; + bool last_line = false; + char *str, *endp; + +#define SYMBOL(sym) { \ + .str = "SYMBOL(" #sym ")=", \ + .name = #sym, \ + .len = sizeof("SYMBOL(" #sym ")=") - 1, \ + .vaddr = & sym ## _vaddr, \ + } + static struct symbol { + const char *str; + const char *name; + size_t len; + loff_t *vaddr; + } symbol[] = { + SYMBOL(prb), + SYMBOL(log_buf), + SYMBOL(log_end), + SYMBOL(log_buf_len), + SYMBOL(logged_chars), + SYMBOL(log_first_idx), + SYMBOL(log_next_idx), + }; + + for (pos = start; pos <= last; pos = eol + 1) { + size_t len, i; + /* Find the end of the current line */ + for (eol = pos; (eol <= last) && (*eol != '\n') ; eol++) + ; + if (eol > last) { + /* + * We did not find \n and note ended. Currently kernel + * is appending last field CRASH_TIME without \n. It + * is ugly but handle it. + */ + eol = last; + len = eol - pos + 1; + if (len >= sizeof(temp_buf)) + len = sizeof(temp_buf) - 1; + strncpy(temp_buf, pos, len); + temp_buf[len + 1] = '\0'; + + pos = temp_buf; + len = len + 1; + eol = pos + len -1; + last_line = true; + } else { + len = eol - pos + 1; + } + + /* Stomp the last character so I am guaranteed a terminating null */ + *eol = '\0'; + /* Copy OSRELEASE if I see it */ + if ((len >= 10) && (memcmp("OSRELEASE=", pos, 10) == 0)) { + size_t to_copy = len - 10; + if (to_copy >= sizeof(osrelease)) + to_copy = sizeof(osrelease) - 1; + memcpy(osrelease, pos + 10, to_copy); + osrelease[to_copy] = '\0'; + } + /* See if the line is mentions a symbol I am looking for */ + for (i = 0; i < sizeof(symbol)/sizeof(symbol[0]); i++ ) { + unsigned long long vaddr; + if (symbol[i].len >= len) + continue; + if (memcmp(symbol[i].str, pos, symbol[i].len) != 0) + continue; + /* Found a symbol now decode it */ + vaddr = strtoull(pos + symbol[i].len, NULL, 16); + /* Remember the virtual address */ + *symbol[i].vaddr = vaddr; + } + + str = "SIZE(printk_ringbuffer)="; + if (memcmp(str, pos, strlen(str)) == 0) + printk_ringbuffer_sz = strtoull(pos + strlen(str), + NULL, 10); + + str = "SIZE(prb_desc)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_desc_sz = strtoull(pos + strlen(str), NULL, 10); + + str = "SIZE(printk_info)="; + if (memcmp(str, pos, strlen(str)) == 0) + printk_info_sz = strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(printk_ringbuffer.desc_ring)="; + if (memcmp(str, pos, strlen(str)) == 0) + printk_ringbuffer_desc_ring_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(printk_ringbuffer.text_data_ring)="; + if (memcmp(str, pos, strlen(str)) == 0) + printk_ringbuffer_text_data_ring_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(prb_desc_ring.count_bits)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_desc_ring_count_bits_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(prb_desc_ring.descs)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_desc_ring_descs_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(prb_desc_ring.infos)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_desc_ring_infos_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(prb_data_ring.size_bits)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_data_ring_size_bits_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(prb_data_ring.data)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_data_ring_data_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(prb_desc_ring.head_id)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_desc_ring_head_id_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(prb_desc_ring.tail_id)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_desc_ring_tail_id_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(atomic_long_t.counter)="; + if (memcmp(str, pos, strlen(str)) == 0) + atomic_long_t_counter_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(prb_desc.state_var)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_desc_state_var_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(prb_desc.info)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_desc_info_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(prb_desc.text_blk_lpos)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_desc_text_blk_lpos_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(prb_data_blk_lpos.begin)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_data_blk_lpos_begin_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(prb_data_blk_lpos.next)="; + if (memcmp(str, pos, strlen(str)) == 0) + prb_data_blk_lpos_next_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(printk_info.seq)="; + if (memcmp(str, pos, strlen(str)) == 0) + printk_info_seq_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(printk_info.caller_id)="; + if (memcmp(str, pos, strlen(str)) == 0) + printk_info_caller_id_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(printk_info.ts_nsec)="; + if (memcmp(str, pos, strlen(str)) == 0) + printk_info_ts_nsec_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(printk_info.level)="; + if (memcmp(str, pos, strlen(str)) == 0) + printk_info_level_offset = + strtoull(pos + strlen(str), NULL, 10); + + str = "OFFSET(printk_info.text_len)="; + if (memcmp(str, pos, strlen(str)) == 0) + printk_info_text_len_offset = + strtoull(pos + strlen(str), NULL, 10); + + /* Check for "SIZE(printk_log)" or older "SIZE(log)=" */ + str = "SIZE(log)="; + if (memcmp(str, pos, strlen(str)) == 0) + log_sz = strtoull(pos + strlen(str), NULL, 10); + + str = "SIZE(printk_log)="; + if (memcmp(str, pos, strlen(str)) == 0) + log_sz = strtoull(pos + strlen(str), NULL, 10); + + /* Check for struct printk_log (or older log) field offsets */ + str = "OFFSET(log.ts_nsec)="; + if (memcmp(str, pos, strlen(str)) == 0) + log_offset_ts_nsec = strtoull(pos + strlen(str), NULL, + 10); + str = "OFFSET(printk_log.ts_nsec)="; + if (memcmp(str, pos, strlen(str)) == 0) + log_offset_ts_nsec = strtoull(pos + strlen(str), NULL, + 10); + + str = "OFFSET(log.len)="; + if (memcmp(str, pos, strlen(str)) == 0) + log_offset_len = strtoul(pos + strlen(str), NULL, 10); + + str = "OFFSET(printk_log.len)="; + if (memcmp(str, pos, strlen(str)) == 0) + log_offset_len = strtoul(pos + strlen(str), NULL, 10); + + str = "OFFSET(log.text_len)="; + if (memcmp(str, pos, strlen(str)) == 0) + log_offset_text_len = strtoul(pos + strlen(str), NULL, + 10); + str = "OFFSET(printk_log.text_len)="; + if (memcmp(str, pos, strlen(str)) == 0) + log_offset_text_len = strtoul(pos + strlen(str), NULL, + 10); + + /* Check for PHYS_OFFSET number */ + str = "NUMBER(PHYS_OFFSET)="; + if (memcmp(str, pos, strlen(str)) == 0) { + phys_offset = strtoul(pos + strlen(str), &endp, + 10); + if (strlen(endp) != 0) + phys_offset = strtoul(pos + strlen(str), &endp, 16); + if ((phys_offset == LONG_MAX) || strlen(endp) != 0) { + fprintf(stderr, "Invalid data %s\n", + pos); + break; + } + } + + if (arch_scan_vmcoreinfo != NULL) + (*arch_scan_vmcoreinfo)(pos); + + if (last_line) + break; + } +} + +static int scan_notes(int fd, loff_t start, loff_t lsize) +{ + char *buf, *last, *note, *next; + size_t size; + ssize_t ret; + + if (lsize > SSIZE_MAX) { + fprintf(stderr, "Unable to handle note section of %llu bytes\n", + (unsigned long long)lsize); + exit(20); + } + + size = lsize; + buf = malloc(size); + if (!buf) { + fprintf(stderr, "Cannot malloc %zu bytes\n", size); + exit(21); + } + last = buf + size - 1; + ret = pread(fd, buf, size, start); + if (ret != (ssize_t)size) { + fprintf(stderr, "Cannot read note section @ 0x%llx of %zu bytes: %s\n", + (unsigned long long)start, size, strerror(errno)); + exit(22); + } + + for (note = buf; (note + sizeof(Elf_Nhdr)) < last; note = next) + { + Elf_Nhdr *hdr; + char *n_name, *n_desc; + size_t n_namesz, n_descsz, n_type; + + hdr = (Elf_Nhdr *)note; + n_namesz = file32_to_cpu(hdr->n_namesz); + n_descsz = file32_to_cpu(hdr->n_descsz); + n_type = file32_to_cpu(hdr->n_type); + + n_name = note + sizeof(*hdr); + n_desc = n_name + ((n_namesz + 3) & ~3); + next = n_desc + ((n_descsz + 3) & ~3); + + if (next > (last + 1)) + break; + + if ((memcmp(n_name, "VMCOREINFO", 11) != 0) || (n_type != 0)) + continue; + scan_vmcoreinfo(n_desc, n_descsz); + } + + if ((note + sizeof(Elf_Nhdr)) == last) { + free(buf); + return -1; + } + + free(buf); + + return 0; +} + +static int scan_note_headers(int fd) +{ + int i, ret = 0; + + for (i = 0; i < ehdr.e_phnum; i++) { + if (phdr[i].p_type != PT_NOTE) + continue; + ret = scan_notes(fd, phdr[i].p_offset, phdr[i].p_filesz); + } + + return ret; +} + +static uint64_t read_file_pointer(int fd, uint64_t addr) +{ + uint64_t result; + ssize_t ret; + + if (machine_pointer_bits() == 64) { + uint64_t scratch; + ret = pread(fd, &scratch, sizeof(scratch), addr); + if (ret != sizeof(scratch)) { + fprintf(stderr, "Failed to read pointer @ 0x%llx: %s\n", + (unsigned long long)addr, strerror(errno)); + exit(40); + } + result = file64_to_cpu(scratch); + } else { + uint32_t scratch; + ret = pread(fd, &scratch, sizeof(scratch), addr); + if (ret != sizeof(scratch)) { + fprintf(stderr, "Failed to read pointer @ 0x%llx: %s\n", + (unsigned long long)addr, strerror(errno)); + exit(40); + } + result = file32_to_cpu(scratch); + } + return result; +} + +static uint32_t read_file_u32(int fd, uint64_t addr) +{ + uint32_t scratch; + ssize_t ret; + ret = pread(fd, &scratch, sizeof(scratch), addr); + if (ret != sizeof(scratch)) { + fprintf(stderr, "Failed to read value @ 0x%llx: %s\n", + (unsigned long long)addr, strerror(errno)); + exit(41); + } + return file32_to_cpu(scratch); +} + +static int32_t read_file_s32(int fd, uint64_t addr) +{ + return read_file_u32(fd, addr); +} + +static void dump_dmesg_legacy(int fd, void (*handler)(char*, unsigned int)) +{ + uint64_t log_buf, log_buf_offset; + unsigned log_end, logged_chars, log_end_wrapped; + int log_buf_len, to_wrap; + char *buf; + ssize_t ret; + + if (!log_buf_vaddr) { + fprintf(stderr, "Missing the log_buf symbol\n"); + exit(50); + } + if (!log_end_vaddr) { + fprintf(stderr, "Missing the log_end symbol\n"); + exit(51); + } + if (!log_buf_len_vaddr) { + fprintf(stderr, "Missing the log_bug_len symbol\n"); + exit(52); + } + if (!logged_chars_vaddr) { + fprintf(stderr, "Missing the logged_chars symbol\n"); + exit(53); + } + + log_buf = read_file_pointer(fd, vaddr_to_offset(log_buf_vaddr)); + log_end = read_file_u32(fd, vaddr_to_offset(log_end_vaddr)); + log_buf_len = read_file_s32(fd, vaddr_to_offset(log_buf_len_vaddr)); + logged_chars = read_file_u32(fd, vaddr_to_offset(logged_chars_vaddr)); + + log_buf_offset = vaddr_to_offset(log_buf); + + buf = calloc(1, log_buf_len); + if (!buf) { + fprintf(stderr, "Failed to malloc %d bytes for the logbuf: %s\n", + log_buf_len, strerror(errno)); + exit(51); + } + + log_end_wrapped = log_end % log_buf_len; + to_wrap = log_buf_len - log_end_wrapped; + + ret = pread(fd, buf, to_wrap, log_buf_offset + log_end_wrapped); + if (ret != to_wrap) { + fprintf(stderr, "Failed to read the first half of the log buffer: %s\n", + strerror(errno)); + exit(52); + } + ret = pread(fd, buf + to_wrap, log_end_wrapped, log_buf_offset); + if (ret != log_end_wrapped) { + fprintf(stderr, "Faield to read the second half of the log buffer: %s\n", + strerror(errno)); + exit(53); + } + + /* + * To collect full dmesg including the part before `dmesg -c` is useful + * for later debugging. Use same logic as what crash utility is using. + */ + logged_chars = log_end < log_buf_len ? log_end : log_buf_len; + + if (handler) + handler(buf + (log_buf_len - logged_chars), logged_chars); +} + +static inline uint16_t struct_val_u16(char *ptr, unsigned int offset) +{ + return(file16_to_cpu(*(uint16_t *)(ptr + offset))); +} + +static inline uint32_t struct_val_u32(char *ptr, unsigned int offset) +{ + return(file32_to_cpu(*(uint32_t *)(ptr + offset))); +} + +static inline uint64_t struct_val_u64(char *ptr, unsigned int offset) +{ + return(file64_to_cpu(*(uint64_t *)(ptr + offset))); +} + +/* Read headers of log records and dump accordingly */ +static void dump_dmesg_structured(int fd, void (*handler)(char*, unsigned int)) +{ +#define OUT_BUF_SIZE 4096 + uint64_t log_buf, log_buf_offset, ts_nsec; + uint32_t log_buf_len, log_first_idx, log_next_idx, current_idx, len = 0, i; + char *buf, out_buf[OUT_BUF_SIZE]; + bool has_wrapped_around = false; + ssize_t ret; + char *msg; + uint16_t text_len; + imaxdiv_t imaxdiv_sec, imaxdiv_usec; + + if (!log_buf_vaddr) { + fprintf(stderr, "Missing the log_buf symbol\n"); + exit(60); + } + + if (!log_buf_len_vaddr) { + fprintf(stderr, "Missing the log_bug_len symbol\n"); + exit(61); + } + + if (!log_first_idx_vaddr) { + fprintf(stderr, "Missing the log_first_idx symbol\n"); + exit(62); + } + + if (!log_next_idx_vaddr) { + fprintf(stderr, "Missing the log_next_idx symbol\n"); + exit(63); + } + + if (!log_sz) { + fprintf(stderr, "Missing the struct log size export\n"); + exit(64); + } + + if (log_offset_ts_nsec == UINT64_MAX) { + fprintf(stderr, "Missing the log.ts_nsec offset export\n"); + exit(65); + } + + if (log_offset_len == UINT16_MAX) { + fprintf(stderr, "Missing the log.len offset export\n"); + exit(66); + } + + if (log_offset_text_len == UINT16_MAX) { + fprintf(stderr, "Missing the log.text_len offset export\n"); + exit(67); + } + + log_buf = read_file_pointer(fd, vaddr_to_offset(log_buf_vaddr)); + log_buf_len = read_file_s32(fd, vaddr_to_offset(log_buf_len_vaddr)); + + log_first_idx = read_file_u32(fd, vaddr_to_offset(log_first_idx_vaddr)); + log_next_idx = read_file_u32(fd, vaddr_to_offset(log_next_idx_vaddr)); + + log_buf_offset = vaddr_to_offset(log_buf); + + buf = calloc(1, log_sz); + if (!buf) { + fprintf(stderr, "Failed to malloc %" PRId64 " bytes for the log:" + " %s\n", log_sz, strerror(errno)); + exit(64); + } + + /* Parse records and write out data at standard output */ + + current_idx = log_first_idx; + len = 0; + while (current_idx != log_next_idx) { + uint16_t loglen; + + ret = pread(fd, buf, log_sz, log_buf_offset + current_idx); + if (ret != log_sz) { + fprintf(stderr, "Failed to read log of size %" PRId64 " bytes:" + " %s\n", log_sz, strerror(errno)); + exit(65); + } + ts_nsec = struct_val_u64(buf, log_offset_ts_nsec); + imaxdiv_sec = imaxdiv(ts_nsec, 1000000000); + imaxdiv_usec = imaxdiv(imaxdiv_sec.rem, 1000); + + len += sprintf(out_buf + len, "[%5llu.%06llu] ", + (long long unsigned int)imaxdiv_sec.quot, + (long long unsigned int)imaxdiv_usec.quot); + + /* escape non-printable characters */ + text_len = struct_val_u16(buf, log_offset_text_len); + msg = calloc(1, text_len); + if (!msg) { + fprintf(stderr, "Failed to malloc %u bytes for log text:" + " %s\n", text_len, strerror(errno)); + exit(64); + } + + ret = pread(fd, msg, text_len, log_buf_offset + current_idx + log_sz); + if (ret != text_len) { + fprintf(stderr, "Failed to read log text of size %u bytes:" + " %s\n", text_len, strerror(errno)); + exit(65); + } + for (i = 0; i < text_len; i++) { + unsigned char c = msg[i]; + + if (!isprint(c) && !isspace(c)) + len += sprintf(out_buf + len, "\\x%02x", c); + else + out_buf[len++] = c; + + if (len >= OUT_BUF_SIZE - 64) { + if (handler) + handler(out_buf, len); + len = 0; + } + } + + out_buf[len++] = '\n'; + free(msg); + /* + * A length == 0 record is the end of buffer marker. Wrap around + * and read the message at the start of the buffer. + */ + loglen = struct_val_u16(buf, log_offset_len); + if (!loglen) { + if (has_wrapped_around) { + if (len && handler) + handler(out_buf, len); + fprintf(stderr, "Cycle when parsing dmesg detected.\n"); + fprintf(stderr, "The prink log_buf is most likely corrupted.\n"); + fprintf(stderr, "log_buf = 0x%lx, idx = 0x%x\n", + log_buf, current_idx); + exit(68); + } + current_idx = 0; + has_wrapped_around = true; + } else { + /* Move to next record */ + current_idx += loglen; + if(current_idx > log_buf_len - log_sz) { + if (len && handler) + handler(out_buf, len); + fprintf(stderr, "Index outside log_buf detected.\n"); + fprintf(stderr, "The prink log_buf is most likely corrupted.\n"); + fprintf(stderr, "log_buf = 0x%lx, idx = 0x%x\n", + log_buf, current_idx); + exit(69); + } + } + } + free(buf); + if (len && handler) + handler(out_buf, len); +} + +/* convenience struct for passing many values to helper functions */ +struct prb_map { + char *prb; + + char *desc_ring; + unsigned long desc_ring_count; + char *descs; + + char *infos; + + char *text_data_ring; + unsigned long text_data_ring_size; + char *text_data; +}; + +/* + * desc_state and DESC_* definitions taken from kernel source: + * + * kernel/printk/printk_ringbuffer.h + * + * DESC_* definitions modified to provide 32-bit and 64-bit variants. + */ + +/* The possible responses of a descriptor state-query. */ +enum desc_state { + desc_miss = -1, /* ID mismatch (pseudo state) */ + desc_reserved = 0x0, /* reserved, in use by writer */ + desc_committed = 0x1, /* committed by writer, could get reopened */ + desc_finalized = 0x2, /* committed, no further modification allowed */ + desc_reusable = 0x3, /* free, not yet used by any writer */ +}; + +#define DESC_SV_BITS (sizeof(uint64_t) * 8) +#define DESC_FLAGS_SHIFT (DESC_SV_BITS - 2) +#define DESC_FLAGS_MASK (3ULL << DESC_FLAGS_SHIFT) +#define DESC_STATE(sv) (3ULL & (sv >> DESC_FLAGS_SHIFT)) +#define DESC_ID_MASK (~DESC_FLAGS_MASK) +#define DESC_ID(sv) ((sv) & DESC_ID_MASK) + +#define DESC32_SV_BITS (sizeof(uint32_t) * 8) +#define DESC32_FLAGS_SHIFT (DESC32_SV_BITS - 2) +#define DESC32_FLAGS_MASK (3UL << DESC32_FLAGS_SHIFT) +#define DESC32_STATE(sv) (3UL & (sv >> DESC32_FLAGS_SHIFT)) +#define DESC32_ID_MASK (~DESC32_FLAGS_MASK) +#define DESC32_ID(sv) ((sv) & DESC32_ID_MASK) + +/* + * get_desc_state() taken from kernel source: + * + * kernel/printk/printk_ringbuffer.c + * + * get_desc32_state() added as 32-bit variant. + */ + +/* Query the state of a descriptor. */ +static enum desc_state get_desc_state(unsigned long id, + uint64_t state_val) +{ + if (id != DESC_ID(state_val)) + return desc_miss; + + return DESC_STATE(state_val); +} + +static enum desc_state get_desc32_state(unsigned long id, + uint64_t state_val) +{ + if (id != DESC32_ID(state_val)) + return desc_miss; + + return DESC32_STATE(state_val); +} + +static bool record_committed(unsigned long id, uint64_t state_var) +{ + enum desc_state state; + + if (machine_pointer_bits() == 32) + state = get_desc32_state(id, state_var); + else + state = get_desc_state(id, state_var); + + return (state == desc_committed || state == desc_finalized); +} + +static uint64_t id_inc(uint64_t id) +{ + id++; + + if (machine_pointer_bits() == 32) + return (id & DESC32_ID_MASK); + + return (id & DESC_ID_MASK); +} + +static uint64_t get_ulong(char *addr) +{ + if (machine_pointer_bits() == 32) + return struct_val_u32(addr, 0); + return struct_val_u64(addr, 0); +} + +static uint64_t sizeof_ulong(void) +{ + return (machine_pointer_bits() >> 3); +} + +static void dump_record(struct prb_map *m, unsigned long id, + void (*handler)(char*, unsigned int)) +{ +#define OUT_BUF_SIZE 4096 + char out_buf[OUT_BUF_SIZE]; + imaxdiv_t imaxdiv_usec; + imaxdiv_t imaxdiv_sec; + uint32_t offset = 0; + unsigned short len; + uint64_t state_var; + uint64_t ts_nsec; + uint64_t begin; + uint64_t next; + char *info; + char *text; + char *desc; + int i; + + desc = m->descs + ((id % m->desc_ring_count) * prb_desc_sz); + info = m->infos + ((id % m->desc_ring_count) * printk_info_sz); + + /* skip non-committed record */ + state_var = get_ulong(desc + prb_desc_state_var_offset + + atomic_long_t_counter_offset); + if (!record_committed(id, state_var)) + return; + + begin = get_ulong(desc + prb_desc_text_blk_lpos_offset + + prb_data_blk_lpos_begin_offset) % + m->text_data_ring_size; + next = get_ulong(desc + prb_desc_text_blk_lpos_offset + + prb_data_blk_lpos_next_offset) % + m->text_data_ring_size; + + ts_nsec = struct_val_u64(info, printk_info_ts_nsec_offset); + imaxdiv_sec = imaxdiv(ts_nsec, 1000000000); + imaxdiv_usec = imaxdiv(imaxdiv_sec.rem, 1000); + + offset += sprintf(out_buf + offset, "[%5llu.%06llu] ", + (long long unsigned int)imaxdiv_sec.quot, + (long long unsigned int)imaxdiv_usec.quot); + + /* skip data-less text blocks */ + if (begin == next) + goto out; + + len = struct_val_u16(info, printk_info_text_len_offset); + + /* handle wrapping data block */ + if (begin > next) + begin = 0; + + /* skip over descriptor ID */ + begin += sizeof_ulong(); + + /* handle truncated messages */ + if (next - begin < len) + len = next - begin; + + text = m->text_data + begin; + + /* escape non-printable characters */ + for (i = 0; i < len; i++) { + unsigned char c = text[i]; + + if (!isprint(c) && !isspace(c)) + offset += sprintf(out_buf + offset, "\\x%02x", c); + else + out_buf[offset++] = c; + + if (offset >= OUT_BUF_SIZE - 64) { + if (handler) + handler(out_buf, offset); + offset = 0; + } + } +out: + out_buf[offset++] = '\n'; + + if (offset && handler) + handler(out_buf, offset); +} + +/* + * Handle the lockless printk_ringbuffer. + */ +static void dump_dmesg_lockless(int fd, void (*handler)(char*, unsigned int)) +{ + struct prb_map m; + uint64_t head_id; + uint64_t tail_id; + uint64_t kaddr; + uint64_t id; + int ret; + + /* setup printk_ringbuffer */ + kaddr = read_file_pointer(fd, vaddr_to_offset(prb_vaddr)); + m.prb = calloc(1, printk_ringbuffer_sz); + if (!m.prb) { + fprintf(stderr, "Failed to malloc %zu bytes for prb: %s\n", + printk_ringbuffer_sz, strerror(errno)); + exit(64); + } + ret = pread(fd, m.prb, printk_ringbuffer_sz, vaddr_to_offset(kaddr)); + if (ret != printk_ringbuffer_sz) { + fprintf(stderr, "Failed to read prb of size %zu bytes: %s\n", + printk_ringbuffer_sz, strerror(errno)); + exit(65); + } + + /* setup descriptor ring */ + m.desc_ring = m.prb + printk_ringbuffer_desc_ring_offset; + m.desc_ring_count = 1 << struct_val_u32(m.desc_ring, + prb_desc_ring_count_bits_offset); + kaddr = get_ulong(m.desc_ring + prb_desc_ring_descs_offset); + m.descs = calloc(1, prb_desc_sz * m.desc_ring_count); + if (!m.descs) { + fprintf(stderr, "Failed to malloc %lu bytes for descs: %s\n", + prb_desc_sz * m.desc_ring_count, strerror(errno)); + exit(64); + } + ret = pread(fd, m.descs, prb_desc_sz * m.desc_ring_count, + vaddr_to_offset(kaddr)); + if (ret != prb_desc_sz * m.desc_ring_count) { + fprintf(stderr, + "Failed to read descs of size %lu bytes: %s\n", + prb_desc_sz * m.desc_ring_count, strerror(errno)); + exit(65); + } + + /* setup info ring */ + kaddr = get_ulong(m.prb + prb_desc_ring_infos_offset); + m.infos = calloc(1, printk_info_sz * m.desc_ring_count); + if (!m.infos) { + fprintf(stderr, "Failed to malloc %lu bytes for infos: %s\n", + printk_info_sz * m.desc_ring_count, strerror(errno)); + exit(64); + } + ret = pread(fd, m.infos, printk_info_sz * m.desc_ring_count, + vaddr_to_offset(kaddr)); + if (ret != printk_info_sz * m.desc_ring_count) { + fprintf(stderr, + "Failed to read infos of size %lu bytes: %s\n", + printk_info_sz * m.desc_ring_count, strerror(errno)); + exit(65); + } + + /* setup text data ring */ + m.text_data_ring = m.prb + printk_ringbuffer_text_data_ring_offset; + m.text_data_ring_size = 1 << struct_val_u32(m.text_data_ring, + prb_data_ring_size_bits_offset); + kaddr = get_ulong(m.text_data_ring + prb_data_ring_data_offset); + m.text_data = calloc(1, m.text_data_ring_size); + if (!m.text_data) { + fprintf(stderr, + "Failed to malloc %lu bytes for text_data: %s\n", + m.text_data_ring_size, strerror(errno)); + exit(64); + } + ret = pread(fd, m.text_data, m.text_data_ring_size, + vaddr_to_offset(kaddr)); + if (ret != m.text_data_ring_size) { + fprintf(stderr, + "Failed to read text_data of size %lu bytes: %s\n", + m.text_data_ring_size, strerror(errno)); + exit(65); + } + + /* ready to go */ + + tail_id = get_ulong(m.desc_ring + prb_desc_ring_tail_id_offset + + atomic_long_t_counter_offset); + head_id = get_ulong(m.desc_ring + prb_desc_ring_head_id_offset + + atomic_long_t_counter_offset); + + for (id = tail_id; id != head_id; id = id_inc(id)) + dump_record(&m, id, handler); + + /* dump head record */ + dump_record(&m, id, handler); + + free(m.text_data); + free(m.infos); + free(m.descs); + free(m.prb); +} + +void dump_dmesg(int fd, void (*handler)(char*, unsigned int)) +{ + if (prb_vaddr) + dump_dmesg_lockless(fd, handler); + else if (log_first_idx_vaddr) + dump_dmesg_structured(fd, handler); + else + dump_dmesg_legacy(fd, handler); +} + +int read_elf(int fd) +{ + int ret; + + ret = pread(fd, ehdr.e_ident, EI_NIDENT, 0); + if (ret != EI_NIDENT) { + fprintf(stderr, "Read of e_ident from %s failed: %s\n", + fname, strerror(errno)); + return 3; + } + if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0) { + fprintf(stderr, "Missing elf signature\n"); + return 4; + } + if (ehdr.e_ident[EI_VERSION] != EV_CURRENT) { + fprintf(stderr, "Bad elf version\n"); + return 5; + } + if ((ehdr.e_ident[EI_CLASS] != ELFCLASS32) && + (ehdr.e_ident[EI_CLASS] != ELFCLASS64)) + { + fprintf(stderr, "Unknown elf class %u\n", + ehdr.e_ident[EI_CLASS]); + return 6; + } + if ((ehdr.e_ident[EI_DATA] != ELFDATA2LSB) && + (ehdr.e_ident[EI_DATA] != ELFDATA2MSB)) + { + fprintf(stderr, "Unkown elf data order %u\n", + ehdr.e_ident[EI_DATA]); + return 7; + } + if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) + read_elf32(fd); + else + read_elf64(fd); + + ret = scan_note_headers(fd); + if (ret < 0) + return ret; + + return 0; +} + +int read_phys_offset_elf_kcore(int fd, long *phys_off) +{ + int ret; + + *phys_off = ULONG_MAX; + + ret = read_elf(fd); + if (!ret) { + /* If we have a valid 'PHYS_OFFSET' by now, + * return it to the caller now. + */ + if (phys_offset != UINT64_MAX) { + *phys_off = phys_offset; + return ret; + } + } + + return 2; +} |