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

Commit 6f016c2e authored by Elliot Berman's avatar Elliot Berman
Browse files

soc: qcom: Add snapshot of minidump 



Add snapshot of minidump as of commit <f94ba33e3b90> ("Merge "usb:
dwc3-msm: Fix GDSC collapse in host mode bus suspend"").

Change-Id: Ie322154aefa3b5d482549188096dc613bde1badf
[eberman@codeaurora.org: minidump Kconfig to tristate]
Signed-off-by: default avatarElliot Berman <eberman@codeaurora.org>
parent d5cc8a27

drivers/soc/qcom/Kconfig

+17 −0
Original line number Diff line number Diff line
@@ -377,6 +377,23 @@ config QCOM_DCC_V2 
         driver provides interface to configure DCC block and read back

         captured data from DCC's internal SRAM.



config QCOM_MINIDUMP

	tristate "QCOM Minidump Support"

	depends on QCOM_SMEM && POWER_RESET_QCOM

	help

	  This enables minidump feature. It allows various clients to

	  register to dump their state at system bad state (panic/WDT,etc.,).

	  Minidump would dump all registered entries, only when DLOAD mode

	  is enabled.



config MINIDUMP_MAX_ENTRIES

	int "Minidump Maximum num of entries"

	default 200

	depends on QCOM_MINIDUMP

	help

	  This defines maximum number of entries to be allocated for application

	  subsytem in Minidump table.



config QCOM_APR

	tristate "Qualcomm APR Bus (Asynchronous Packet Router)"

	depends on ARCH_QCOM || COMPILE_TEST

drivers/soc/qcom/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ obj-$(CONFIG_QCOM_IPCC) += qcom_ipcc.o 
obj-$(CONFIG_QCOM_APR) += apr.o

obj-$(CONFIG_QCOM_LLCC) += llcc-slice.o

obj-$(CONFIG_QCOM_LAHAINA_LLCC) += llcc-lahaina.o

obj-$(CONFIG_QCOM_MINIDUMP) += msm_minidump.o minidump_log.o

obj-$(CONFIG_QCOM_MEMORY_DUMP_V2) += memory_dump_v2.o

obj-$(CONFIG_QCOM_DCC_V2) += dcc_v2.o

obj-$(CONFIG_MSM_JTAGV8) += jtagv8.o jtagv8-etm.o

drivers/soc/qcom/minidump_log.c

0 → 100644
+165 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.

 */



#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/kallsyms.h>

#include <linux/slab.h>

#include <linux/thread_info.h>

#include <soc/qcom/minidump.h>

#include <asm/sections.h>

#include <linux/mm.h>

#include <linux/sched/task.h>

#include <linux/vmalloc.h>



static void __init register_log_buf(void)

{

	char **log_bufp;

	uint32_t *log_buf_lenp;

	struct md_region md_entry;



	log_bufp = (char **)kallsyms_lookup_name("log_buf");

	log_buf_lenp = (uint32_t *)kallsyms_lookup_name("log_buf_len");

	if (!log_bufp || !log_buf_lenp) {

		pr_err("Unable to find log_buf by kallsyms!\n");

		return;

	}

	/*Register logbuf to minidump, first idx would be from bss section */

	strlcpy(md_entry.name, "KLOGBUF", sizeof(md_entry.name));

	md_entry.virt_addr = (uintptr_t) (*log_bufp);

	md_entry.phys_addr = virt_to_phys(*log_bufp);

	md_entry.size = *log_buf_lenp;

	if (msm_minidump_add_region(&md_entry))

		pr_err("Failed to add logbuf in Minidump\n");

}



static void register_stack_entry(struct md_region *ksp_entry, u64 sp, u64 size,

				 u32 cpu)

{

	struct page *sp_page;

	struct vm_struct *stack_vm_area = task_stack_vm_area(current);



	ksp_entry->virt_addr = sp;

	ksp_entry->size = size;

	if (stack_vm_area) {

		sp_page = vmalloc_to_page((const void *) sp);

		ksp_entry->phys_addr = page_to_phys(sp_page);

	} else {

		ksp_entry->phys_addr = virt_to_phys((uintptr_t *)sp);

	}



	if (msm_minidump_add_region(ksp_entry))

		pr_err("Failed to add stack of cpu %d in Minidump\n", cpu);

}



static void __init register_kernel_sections(void)

{

	struct md_region ksec_entry;

	char *data_name = "KDATABSS";

	const size_t static_size = __per_cpu_end - __per_cpu_start;

	void __percpu *base = (void __percpu *)__per_cpu_start;

	unsigned int cpu;



	strlcpy(ksec_entry.name, data_name, sizeof(ksec_entry.name));

	ksec_entry.virt_addr = (uintptr_t)_sdata;

	ksec_entry.phys_addr = virt_to_phys(_sdata);

	ksec_entry.size = roundup((__bss_stop - _sdata), 4);

	if (msm_minidump_add_region(&ksec_entry))

		pr_err("Failed to add data section in Minidump\n");



	/* Add percpu static sections */

	for_each_possible_cpu(cpu) {

		void *start = per_cpu_ptr(base, cpu);



		memset(&ksec_entry, 0, sizeof(ksec_entry));

		scnprintf(ksec_entry.name, sizeof(ksec_entry.name),

			"KSPERCPU%d", cpu);

		ksec_entry.virt_addr = (uintptr_t)start;

		ksec_entry.phys_addr = per_cpu_ptr_to_phys(start);

		ksec_entry.size = static_size;

		if (msm_minidump_add_region(&ksec_entry))

			pr_err("Failed to add percpu sections in Minidump\n");

	}

}



static inline bool in_stack_range(u64 sp, u64 base_addr, unsigned int

				  stack_size)

{

	u64 min_addr = base_addr;

	u64 max_addr = base_addr + stack_size;



	return (min_addr <= sp && sp < max_addr);

}



static unsigned int calculate_copy_pages(u64 sp, struct vm_struct *stack_area)

{

	u64 tsk_stack_base = (u64) stack_area->addr;

	u64 offset;

	unsigned int stack_pages, copy_pages;



	if (in_stack_range(sp, tsk_stack_base, get_vm_area_size(stack_area))) {

		offset = sp - tsk_stack_base;

		stack_pages = get_vm_area_size(stack_area) / PAGE_SIZE;

		copy_pages = stack_pages - (offset / PAGE_SIZE);

	} else {

		copy_pages = 0;

	}

	return copy_pages;

}



void dump_stack_minidump(u64 sp)

{

	struct md_region ksp_entry, ktsk_entry;

	u32 cpu = smp_processor_id();

	struct vm_struct *stack_vm_area;

	unsigned int i, copy_pages;



	if (is_idle_task(current))

		return;



	if (sp < KIMAGE_VADDR || sp > -256UL)

		sp = current_stack_pointer;



	/*

	 * Since stacks are now allocated with vmalloc, the translation to

	 * physical address is not a simple linear transformation like it is

	 * for kernel logical addresses, since vmalloc creates a virtual

	 * mapping. Thus, virt_to_phys() should not be used in this context;

	 * instead the page table must be walked to acquire the physical

	 * address of one page of the stack.

	 */

	stack_vm_area = task_stack_vm_area(current);

	if (stack_vm_area) {

		sp &= ~(PAGE_SIZE - 1);

		copy_pages = calculate_copy_pages(sp, stack_vm_area);

		for (i = 0; i < copy_pages; i++) {

			scnprintf(ksp_entry.name, sizeof(ksp_entry.name),

				  "KSTACK%d_%d", cpu, i);

			register_stack_entry(&ksp_entry, sp, PAGE_SIZE, cpu);

			sp += PAGE_SIZE;

		}

	} else {

		sp &= ~(THREAD_SIZE - 1);

		scnprintf(ksp_entry.name, sizeof(ksp_entry.name), "KSTACK%d",

			  cpu);

		register_stack_entry(&ksp_entry, sp, THREAD_SIZE, cpu);

	}



	scnprintf(ktsk_entry.name, sizeof(ktsk_entry.name), "KTASK%d", cpu);

	ktsk_entry.virt_addr = (u64)current;

	ktsk_entry.phys_addr = virt_to_phys((uintptr_t *)current);

	ktsk_entry.size = sizeof(struct task_struct);

	if (msm_minidump_add_region(&ktsk_entry))

		pr_err("Failed to add current task %d in Minidump\n", cpu);

}



static int __init msm_minidump_log_init(void)

{

	register_kernel_sections();

	register_log_buf();

	return 0;

}

late_initcall(msm_minidump_log_init);

drivers/soc/qcom/msm_minidump.c

0 → 100644
+512 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.

 */



#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 <linux/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 int md_region_num(const char *name, int *seqno)

{

	struct md_ss_region *mde = minidump_table.md_regions;

	int i, regno = minidump_table.md_ss_toc->ss_region_count;

	int ret = -EINVAL;



	for (i = 0; i < regno; i++, mde++) {

		if (!strcmp(mde->name, name)) {

			ret = i;

			if (mde->seq_num > *seqno)

				*seqno = mde->seq_num;

		}

	}

	return ret;

}



static inline int md_entry_num(const struct md_region *entry)

{

	struct md_region *mdr;

	int i, regno = minidump_table.num_regions;



	for (i = 0; i < regno; i++) {

		mdr = &minidump_table.entry[i];

		if (!strcmp(mdr->name, entry->name))

			return i;

	}

	return -EINVAL;

}



/* 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 seq = 0, 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;

	if (md_region_num(entry->name, &seq) >= 0)

		mdr->seq_num = seq + 1;



	/* 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;

	minidump_table.md_ss_toc->ss_region_count++;

}



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);



int msm_minidump_add_region(const struct md_region *entry)

{

	u32 entries;

	struct md_region *mdr;



	if (!entry)

		return -EINVAL;



	if ((strlen(entry->name) > MAX_NAME_LENGTH) || !entry->virt_addr ||

		(!IS_ALIGNED(entry->size, 4))) {

		pr_err("Invalid entry details\n");

		return -EINVAL;

	}



	spin_lock(&mdt_lock);

	if (md_entry_num(entry) >= 0) {

		pr_err("Entry name already exist.\n");

		spin_unlock(&mdt_lock);

		return -EINVAL;

	}



	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 0;

}

EXPORT_SYMBOL(msm_minidump_add_region);



int msm_minidump_clear_headers(const struct md_region *entry)

{

	struct elfhdr *hdr = minidump_elfheader.ehdr;

	struct elf_shdr *shdr = NULL, *tshdr = NULL;

	struct elf_phdr *phdr = NULL, *tphdr = NULL;

	int pidx, shidx, strln, i;

	char *shname;

	u64 esize;



	esize = entry->size;

	for (i = 0; i < hdr->e_phnum; i++) {

		phdr = elf_program(hdr, i);

		if ((phdr->p_paddr == entry->phys_addr) &&

			(phdr->p_memsz == entry->size))

			break;

	}

	if (i == hdr->e_phnum) {

		pr_err("Cannot find entry in elf\n");

		return -EINVAL;

	}

	pidx = i;



	for (i = 0; i < hdr->e_shnum; i++) {

		shdr = elf_section(hdr, i);

		shname = elf_lookup_string(hdr, shdr->sh_name);

		if (shname && !strcmp(shname, entry->name))

			if ((shdr->sh_addr == entry->virt_addr) &&

				(shdr->sh_size == entry->size))

				break;



	}

	if (i == hdr->e_shnum) {

		pr_err("Cannot find entry in elf\n");

		return -EINVAL;

	}

	shidx = i;



	if (shdr->sh_offset != phdr->p_offset) {

		pr_err("Invalid entry details in elf, Minidump broken..\n");

		return -EINVAL;

	}



	/* Clear name in string table */

	strln = strlen(shname) + 1;

	memmove(shname, shname + strln,

		(minidump_elfheader.strtable_idx - shdr->sh_name));

	minidump_elfheader.strtable_idx -= strln;



	/* Clear program header */

	tphdr = elf_program(hdr, pidx);

	for (i = pidx; i < hdr->e_phnum - 1; i++) {

		tphdr = elf_program(hdr, i + 1);

		phdr = elf_program(hdr, i);

		memcpy(phdr, tphdr, sizeof(struct elf_phdr));

		phdr->p_offset = phdr->p_offset - esize;

	}

	memset(tphdr, 0, sizeof(struct elf_phdr));

	hdr->e_phnum--;



	/* Clear section header */

	tshdr = elf_section(hdr, shidx);

	for (i = shidx; i < hdr->e_shnum - 1; i++) {

		tshdr = elf_section(hdr, i + 1);

		shdr = elf_section(hdr, i);

		memcpy(shdr, tshdr, sizeof(struct elf_shdr));

		shdr->sh_offset -= esize;

		shdr->sh_name -= strln;

	}

	memset(tshdr, 0, sizeof(struct elf_shdr));

	hdr->e_shnum--;



	minidump_elfheader.elf_offset -= esize;

	return 0;

}



int msm_minidump_remove_region(const struct md_region *entry)

{

	int rcount, ecount, seq = 0, rgno, ret;



	if (!entry || !minidump_table.md_ss_toc ||

		(minidump_table.md_ss_toc->md_ss_enable_status !=

						MD_SS_ENABLED))

		return -EINVAL;



	spin_lock(&mdt_lock);

	ecount = minidump_table.num_regions;

	rcount = minidump_table.md_ss_toc->ss_region_count;

	rgno = md_entry_num(entry);

	if (rgno < 0) {

		pr_err("Not able to find the entry in table\n");

		goto out;

	}



	minidump_table.md_ss_toc->md_ss_toc_init = 0;



	/* Remove entry from: entry list, ss region list and elf header */

	memmove(&minidump_table.entry[rgno], &minidump_table.entry[rgno + 1],

		((ecount - rgno - 1) * sizeof(struct md_region)));

	memset(&minidump_table.entry[ecount - 1], 0, sizeof(struct md_region));





	rgno = md_region_num(entry->name, &seq);

	if (rgno < 0) {

		pr_err("Not able to find region in table\n");

		goto out;

	}



	memmove(&minidump_table.md_regions[rgno],

		&minidump_table.md_regions[rgno + 1],

		((rcount - rgno - 1) * sizeof(struct md_ss_region)));

	memset(&minidump_table.md_regions[rcount - 1], 0,

					sizeof(struct md_ss_region));





	ret = msm_minidump_clear_headers(entry);

	if (ret)

		goto out;



	minidump_table.md_ss_toc->ss_region_count--;

	minidump_table.md_ss_toc->md_ss_toc_init = 1;



	minidump_table.num_regions--;

	spin_unlock(&mdt_lock);

	return 0;

out:

	spin_unlock(&mdt_lock);

	pr_err("Minidump is broken..disable Minidump collection\n");

	return -EINVAL;

}

EXPORT_SYMBOL(msm_minidump_remove_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_t 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 = qcom_smem_get(QCOM_SMEM_HOST_ANY, SBL_MINIDUMP_SMEM_ID,

				      &size);

	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)

include/soc/qcom/minidump.h

+5 −0
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ struct md_region { 
 */

#if IS_ENABLED(CONFIG_QCOM_MINIDUMP)

extern int msm_minidump_add_region(const struct md_region *entry);

extern int msm_minidump_remove_region(const struct md_region *entry);

extern bool msm_minidump_enabled(void);

extern void dump_stack_minidump(u64 sp);

#else
@@ -38,6 +39,10 @@ static inline int msm_minidump_add_region(const struct md_region *entry) 
	/* Return quietly, if minidump is not supported */

	return 0;

}

static inline int msm_minidump_remove_region(const struct md_region *entry)

{

	return 0;

}

static inline bool msm_minidump_enabled(void) { return false; }

static inline void dump_stack_minidump(u64 sp) {}

#endif