| /* Copyright (c) 2017-2018, The Linux Foundation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 and |
| * only version 2 as published by the Free Software Foundation. |
| * |
| * 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. |
| */ |
| #define pr_fmt(fmt) "Minidump: " fmt |
| |
| #include <linux/init.h> |
| #include <linux/export.h> |
| #include <linux/kernel.h> |
| #include <linux/err.h> |
| #include <linux/elf.h> |
| #include <linux/errno.h> |
| #include <linux/string.h> |
| #include <linux/slab.h> |
| #include <soc/qcom/smem.h> |
| #include <soc/qcom/minidump.h> |
| #include "minidump_private.h" |
| |
| #define MAX_NUM_ENTRIES (CONFIG_MINIDUMP_MAX_ENTRIES + 1) |
| #define MAX_STRTBL_SIZE (MAX_NUM_ENTRIES * MAX_REGION_NAME_LENGTH) |
| |
| /** |
| * md_table : Local Minidump toc holder |
| * @num_regions : Number of regions requested |
| * @md_ss_toc : HLOS toc pointer |
| * @md_gbl_toc : Global toc pointer |
| * @md_regions : HLOS regions base pointer |
| * @entry : array of HLOS regions requested |
| */ |
| struct md_table { |
| u32 revision; |
| u32 num_regions; |
| struct md_ss_toc *md_ss_toc; |
| struct md_global_toc *md_gbl_toc; |
| struct md_ss_region *md_regions; |
| struct md_region entry[MAX_NUM_ENTRIES]; |
| }; |
| |
| /** |
| * md_elfhdr: Minidump table elf header |
| * @ehdr: elf main header |
| * @shdr: Section header |
| * @phdr: Program header |
| * @elf_offset: section offset in elf |
| * @strtable_idx: string table current index position |
| */ |
| struct md_elfhdr { |
| struct elfhdr *ehdr; |
| struct elf_shdr *shdr; |
| struct elf_phdr *phdr; |
| u64 elf_offset; |
| u64 strtable_idx; |
| }; |
| |
| /* Protect elfheader and smem table from deferred calls contention */ |
| static DEFINE_SPINLOCK(mdt_lock); |
| static struct md_table minidump_table; |
| static struct md_elfhdr minidump_elfheader; |
| |
| /* Number of pending entries to be added in ToC regions */ |
| static unsigned int pendings; |
| |
| static inline char *elf_lookup_string(struct elfhdr *hdr, int offset) |
| { |
| char *strtab = elf_str_table(hdr); |
| |
| if ((strtab == NULL) || (minidump_elfheader.strtable_idx < offset)) |
| return NULL; |
| return strtab + offset; |
| } |
| |
| static inline unsigned int set_section_name(const char *name) |
| { |
| char *strtab = elf_str_table(minidump_elfheader.ehdr); |
| int idx = minidump_elfheader.strtable_idx; |
| int ret = 0; |
| |
| if ((strtab == NULL) || (name == NULL)) |
| return 0; |
| |
| ret = idx; |
| idx += strlcpy((strtab + idx), name, MAX_REGION_NAME_LENGTH); |
| minidump_elfheader.strtable_idx = idx + 1; |
| |
| return ret; |
| } |
| |
| static inline bool md_check_name(const char *name) |
| { |
| struct md_region *mde = minidump_table.entry; |
| int i, regno = minidump_table.num_regions; |
| |
| for (i = 0; i < regno; i++, mde++) |
| if (!strcmp(mde->name, name)) |
| return true; |
| return false; |
| } |
| |
| /* Return next seq no, if name already exists in the table */ |
| static inline int md_get_seq_num(const char *name) |
| { |
| struct md_ss_region *mde = minidump_table.md_regions; |
| int i, regno = minidump_table.md_ss_toc->ss_region_count; |
| int seqno = 0; |
| |
| for (i = 0; i < (regno - 1); i++, mde++) { |
| if (!strcmp(mde->name, name)) { |
| if (mde->seq_num >= seqno) |
| seqno = mde->seq_num + 1; |
| } |
| } |
| return seqno; |
| } |
| |
| /* Update Mini dump table in SMEM */ |
| static void md_update_ss_toc(const struct md_region *entry) |
| { |
| struct md_ss_region *mdr; |
| struct elfhdr *hdr = minidump_elfheader.ehdr; |
| struct elf_shdr *shdr = elf_section(hdr, hdr->e_shnum++); |
| struct elf_phdr *phdr = elf_program(hdr, hdr->e_phnum++); |
| int reg_cnt = minidump_table.md_ss_toc->ss_region_count++; |
| |
| mdr = &minidump_table.md_regions[reg_cnt]; |
| |
| strlcpy(mdr->name, entry->name, sizeof(mdr->name)); |
| mdr->region_base_address = entry->phys_addr; |
| mdr->region_size = entry->size; |
| mdr->seq_num = md_get_seq_num(entry->name); |
| |
| /* Update elf header */ |
| shdr->sh_type = SHT_PROGBITS; |
| shdr->sh_name = set_section_name(mdr->name); |
| shdr->sh_addr = (elf_addr_t)entry->virt_addr; |
| shdr->sh_size = mdr->region_size; |
| shdr->sh_flags = SHF_WRITE; |
| shdr->sh_offset = minidump_elfheader.elf_offset; |
| shdr->sh_entsize = 0; |
| |
| phdr->p_type = PT_LOAD; |
| phdr->p_offset = minidump_elfheader.elf_offset; |
| phdr->p_vaddr = entry->virt_addr; |
| phdr->p_paddr = entry->phys_addr; |
| phdr->p_filesz = phdr->p_memsz = mdr->region_size; |
| phdr->p_flags = PF_R | PF_W; |
| |
| minidump_elfheader.elf_offset += shdr->sh_size; |
| mdr->md_valid = MD_REGION_VALID; |
| } |
| |
| bool msm_minidump_enabled(void) |
| { |
| bool ret = false; |
| |
| spin_lock(&mdt_lock); |
| if (minidump_table.md_ss_toc && |
| (minidump_table.md_ss_toc->md_ss_enable_status == |
| MD_SS_ENABLED)) |
| ret = true; |
| spin_unlock(&mdt_lock); |
| return ret; |
| } |
| EXPORT_SYMBOL(msm_minidump_enabled); |
| |
| static inline int validate_region(const struct md_region *entry) |
| { |
| if (!entry || (strlen(entry->name) > MAX_NAME_LENGTH) || |
| !entry->virt_addr) { |
| pr_err("Invalid entry details\n"); |
| return -EINVAL; |
| } |
| |
| if (!IS_ALIGNED(entry->size, 4)) { |
| pr_err("size should be 4 byte aligned\n"); |
| return -EINVAL; |
| } |
| return 0; |
| } |
| |
| int msm_minidump_update_region(int regno, const struct md_region *entry) |
| { |
| struct md_region *mdr; |
| struct md_ss_region *mdssr; |
| struct elfhdr *hdr = minidump_elfheader.ehdr; |
| struct elf_shdr *shdr; |
| struct elf_phdr *phdr; |
| |
| if (validate_region(entry) || (regno >= MAX_NUM_ENTRIES)) |
| return -EINVAL; |
| |
| if (!md_check_name(entry->name)) { |
| pr_err("Region:[%s] does not exist to update.\n", entry->name); |
| return -ENOMEM; |
| } |
| |
| mdr = &minidump_table.entry[regno]; |
| mdr->virt_addr = entry->virt_addr; |
| mdr->phys_addr = entry->phys_addr; |
| |
| mdssr = &minidump_table.md_regions[regno + 1]; |
| mdssr->region_base_address = entry->phys_addr; |
| |
| shdr = elf_section(hdr, regno + 4); |
| phdr = elf_program(hdr, regno + 1); |
| |
| shdr->sh_addr = (elf_addr_t)entry->virt_addr; |
| phdr->p_vaddr = entry->virt_addr; |
| phdr->p_paddr = entry->phys_addr; |
| |
| return 0; |
| } |
| EXPORT_SYMBOL(msm_minidump_update_region); |
| |
| int msm_minidump_add_region(const struct md_region *entry) |
| { |
| u32 entries; |
| struct md_region *mdr; |
| |
| if (validate_region(entry)) |
| return -EINVAL; |
| |
| if (md_check_name(entry->name)) { |
| pr_err("Region name [%s] already registered\n", entry->name); |
| return -EEXIST; |
| } |
| |
| spin_lock(&mdt_lock); |
| entries = minidump_table.num_regions; |
| if (entries >= MAX_NUM_ENTRIES) { |
| pr_err("Maximum entries reached.\n"); |
| spin_unlock(&mdt_lock); |
| return -ENOMEM; |
| } |
| |
| mdr = &minidump_table.entry[entries]; |
| strlcpy(mdr->name, entry->name, sizeof(mdr->name)); |
| mdr->virt_addr = entry->virt_addr; |
| mdr->phys_addr = entry->phys_addr; |
| mdr->size = entry->size; |
| mdr->id = entry->id; |
| |
| minidump_table.num_regions = entries + 1; |
| |
| if (minidump_table.md_ss_toc && |
| (minidump_table.md_ss_toc->md_ss_enable_status == |
| MD_SS_ENABLED)) |
| md_update_ss_toc(entry); |
| else |
| pendings++; |
| |
| spin_unlock(&mdt_lock); |
| |
| return entries; |
| } |
| EXPORT_SYMBOL(msm_minidump_add_region); |
| |
| static int msm_minidump_add_header(void) |
| { |
| struct md_ss_region *mdreg = &minidump_table.md_regions[0]; |
| struct elfhdr *ehdr; |
| struct elf_shdr *shdr; |
| struct elf_phdr *phdr; |
| unsigned int strtbl_off, elfh_size, phdr_off; |
| char *banner; |
| |
| /* Header buffer contains: |
| * elf header, MAX_NUM_ENTRIES+4 of section and program elf headers, |
| * string table section and linux banner. |
| */ |
| elfh_size = sizeof(*ehdr) + MAX_STRTBL_SIZE + (strlen(linux_banner) + |
| 1) + ((sizeof(*shdr) + sizeof(*phdr)) * (MAX_NUM_ENTRIES + 4)); |
| elfh_size = ALIGN(elfh_size, 4); |
| |
| minidump_elfheader.ehdr = kzalloc(elfh_size, GFP_KERNEL); |
| if (!minidump_elfheader.ehdr) |
| return -ENOMEM; |
| |
| strlcpy(mdreg->name, "KELF_HEADER", sizeof(mdreg->name)); |
| mdreg->region_base_address = virt_to_phys(minidump_elfheader.ehdr); |
| mdreg->region_size = elfh_size; |
| |
| ehdr = minidump_elfheader.ehdr; |
| /* Assign section/program headers offset */ |
| minidump_elfheader.shdr = shdr = (struct elf_shdr *)(ehdr + 1); |
| minidump_elfheader.phdr = phdr = |
| (struct elf_phdr *)(shdr + MAX_NUM_ENTRIES); |
| phdr_off = sizeof(*ehdr) + (sizeof(*shdr) * MAX_NUM_ENTRIES); |
| |
| memcpy(ehdr->e_ident, ELFMAG, SELFMAG); |
| ehdr->e_ident[EI_CLASS] = ELF_CLASS; |
| ehdr->e_ident[EI_DATA] = ELF_DATA; |
| ehdr->e_ident[EI_VERSION] = EV_CURRENT; |
| ehdr->e_ident[EI_OSABI] = ELF_OSABI; |
| ehdr->e_type = ET_CORE; |
| ehdr->e_machine = ELF_ARCH; |
| ehdr->e_version = EV_CURRENT; |
| ehdr->e_ehsize = sizeof(*ehdr); |
| ehdr->e_phoff = phdr_off; |
| ehdr->e_phentsize = sizeof(*phdr); |
| ehdr->e_shoff = sizeof(*ehdr); |
| ehdr->e_shentsize = sizeof(*shdr); |
| ehdr->e_shstrndx = 1; |
| |
| minidump_elfheader.elf_offset = elfh_size; |
| |
| /* |
| * First section header should be NULL, |
| * 2nd section is string table. |
| */ |
| minidump_elfheader.strtable_idx = 1; |
| strtbl_off = sizeof(*ehdr) + |
| ((sizeof(*phdr) + sizeof(*shdr)) * MAX_NUM_ENTRIES); |
| shdr++; |
| shdr->sh_type = SHT_STRTAB; |
| shdr->sh_offset = (elf_addr_t)strtbl_off; |
| shdr->sh_size = MAX_STRTBL_SIZE; |
| shdr->sh_entsize = 0; |
| shdr->sh_flags = 0; |
| shdr->sh_name = set_section_name("STR_TBL"); |
| shdr++; |
| |
| /* 3rd section is for minidump_table VA, used by parsers */ |
| shdr->sh_type = SHT_PROGBITS; |
| shdr->sh_entsize = 0; |
| shdr->sh_flags = 0; |
| shdr->sh_addr = (elf_addr_t)&minidump_table; |
| shdr->sh_name = set_section_name("minidump_table"); |
| shdr++; |
| |
| /* 4th section is linux banner */ |
| banner = (char *)ehdr + strtbl_off + MAX_STRTBL_SIZE; |
| strlcpy(banner, linux_banner, strlen(linux_banner) + 1); |
| |
| shdr->sh_type = SHT_PROGBITS; |
| shdr->sh_offset = (elf_addr_t)(strtbl_off + MAX_STRTBL_SIZE); |
| shdr->sh_size = strlen(linux_banner) + 1; |
| shdr->sh_addr = (elf_addr_t)linux_banner; |
| shdr->sh_entsize = 0; |
| shdr->sh_flags = SHF_WRITE; |
| shdr->sh_name = set_section_name("linux_banner"); |
| |
| phdr->p_type = PT_LOAD; |
| phdr->p_offset = (elf_addr_t)(strtbl_off + MAX_STRTBL_SIZE); |
| phdr->p_vaddr = (elf_addr_t)linux_banner; |
| phdr->p_paddr = virt_to_phys(linux_banner); |
| phdr->p_filesz = phdr->p_memsz = strlen(linux_banner) + 1; |
| phdr->p_flags = PF_R | PF_W; |
| |
| /* Update headers count*/ |
| ehdr->e_phnum = 1; |
| ehdr->e_shnum = 4; |
| |
| mdreg->md_valid = MD_REGION_VALID; |
| return 0; |
| } |
| |
| static int __init msm_minidump_init(void) |
| { |
| unsigned int i, size; |
| struct md_region *mdr; |
| struct md_global_toc *md_global_toc; |
| struct md_ss_toc *md_ss_toc; |
| |
| /* Get Minidump table */ |
| md_global_toc = smem_get_entry(SBL_MINIDUMP_SMEM_ID, &size, 0, |
| SMEM_ANY_HOST_FLAG); |
| if (IS_ERR_OR_NULL(md_global_toc)) { |
| pr_err("SMEM is not initialized.\n"); |
| return -ENODEV; |
| } |
| |
| /*Check global minidump support initialization */ |
| if (!md_global_toc->md_toc_init) { |
| pr_err("System Minidump TOC not initialized\n"); |
| return -ENODEV; |
| } |
| |
| minidump_table.md_gbl_toc = md_global_toc; |
| minidump_table.revision = md_global_toc->md_revision; |
| md_ss_toc = &md_global_toc->md_ss_toc[MD_SS_HLOS_ID]; |
| |
| md_ss_toc->encryption_status = MD_SS_ENCR_NONE; |
| md_ss_toc->encryption_required = MD_SS_ENCR_REQ; |
| |
| minidump_table.md_ss_toc = md_ss_toc; |
| minidump_table.md_regions = kzalloc((MAX_NUM_ENTRIES * |
| sizeof(struct md_ss_region)), GFP_KERNEL); |
| if (!minidump_table.md_regions) |
| return -ENOMEM; |
| |
| md_ss_toc->md_ss_smem_regions_baseptr = |
| virt_to_phys(minidump_table.md_regions); |
| |
| /* First entry would be ELF header */ |
| md_ss_toc->ss_region_count = 1; |
| msm_minidump_add_header(); |
| |
| /* Add pending entries to HLOS TOC */ |
| spin_lock(&mdt_lock); |
| md_ss_toc->md_ss_toc_init = 1; |
| md_ss_toc->md_ss_enable_status = MD_SS_ENABLED; |
| for (i = 0; i < pendings; i++) { |
| mdr = &minidump_table.entry[i]; |
| md_update_ss_toc(mdr); |
| } |
| |
| pendings = 0; |
| spin_unlock(&mdt_lock); |
| |
| pr_info("Enabled with max number of regions %d\n", |
| CONFIG_MINIDUMP_MAX_ENTRIES); |
| |
| return 0; |
| } |
| subsys_initcall(msm_minidump_init) |