mirror of
https://github.com/torvalds/linux.git
synced 2024-12-13 14:43:03 +00:00
bf41a0910c
Currently "default" configuration option means coredumps are enabled. To avoid confusion rename the "default" configuration option to "enabled" and disable collection of dumps by default as doing so makes sense for production devices. Signed-off-by: Rishabh Bhatnagar <rishabhb@codeaurora.org> Link: https://lore.kernel.org/r/1601662144-5964-2-git-send-email-rishabhb@codeaurora.org Signed-off-by: Bjorn Andersson <bjorn.andersson@linaro.org>
326 lines
8.7 KiB
C
326 lines
8.7 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Coredump functionality for Remoteproc framework.
|
|
*
|
|
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
|
|
*/
|
|
|
|
#include <linux/completion.h>
|
|
#include <linux/devcoredump.h>
|
|
#include <linux/device.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/remoteproc.h>
|
|
#include "remoteproc_internal.h"
|
|
#include "remoteproc_elf_helpers.h"
|
|
|
|
struct rproc_coredump_state {
|
|
struct rproc *rproc;
|
|
void *header;
|
|
struct completion dump_done;
|
|
};
|
|
|
|
/**
|
|
* rproc_coredump_cleanup() - clean up dump_segments list
|
|
* @rproc: the remote processor handle
|
|
*/
|
|
void rproc_coredump_cleanup(struct rproc *rproc)
|
|
{
|
|
struct rproc_dump_segment *entry, *tmp;
|
|
|
|
list_for_each_entry_safe(entry, tmp, &rproc->dump_segments, node) {
|
|
list_del(&entry->node);
|
|
kfree(entry);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* rproc_coredump_add_segment() - add segment of device memory to coredump
|
|
* @rproc: handle of a remote processor
|
|
* @da: device address
|
|
* @size: size of segment
|
|
*
|
|
* Add device memory to the list of segments to be included in a coredump for
|
|
* the remoteproc.
|
|
*
|
|
* Return: 0 on success, negative errno on error.
|
|
*/
|
|
int rproc_coredump_add_segment(struct rproc *rproc, dma_addr_t da, size_t size)
|
|
{
|
|
struct rproc_dump_segment *segment;
|
|
|
|
segment = kzalloc(sizeof(*segment), GFP_KERNEL);
|
|
if (!segment)
|
|
return -ENOMEM;
|
|
|
|
segment->da = da;
|
|
segment->size = size;
|
|
|
|
list_add_tail(&segment->node, &rproc->dump_segments);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(rproc_coredump_add_segment);
|
|
|
|
/**
|
|
* rproc_coredump_add_custom_segment() - add custom coredump segment
|
|
* @rproc: handle of a remote processor
|
|
* @da: device address
|
|
* @size: size of segment
|
|
* @dumpfn: custom dump function called for each segment during coredump
|
|
* @priv: private data
|
|
*
|
|
* Add device memory to the list of segments to be included in the coredump
|
|
* and associate the segment with the given custom dump function and private
|
|
* data.
|
|
*
|
|
* Return: 0 on success, negative errno on error.
|
|
*/
|
|
int rproc_coredump_add_custom_segment(struct rproc *rproc,
|
|
dma_addr_t da, size_t size,
|
|
void (*dumpfn)(struct rproc *rproc,
|
|
struct rproc_dump_segment *segment,
|
|
void *dest, size_t offset,
|
|
size_t size),
|
|
void *priv)
|
|
{
|
|
struct rproc_dump_segment *segment;
|
|
|
|
segment = kzalloc(sizeof(*segment), GFP_KERNEL);
|
|
if (!segment)
|
|
return -ENOMEM;
|
|
|
|
segment->da = da;
|
|
segment->size = size;
|
|
segment->priv = priv;
|
|
segment->dump = dumpfn;
|
|
|
|
list_add_tail(&segment->node, &rproc->dump_segments);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(rproc_coredump_add_custom_segment);
|
|
|
|
/**
|
|
* rproc_coredump_set_elf_info() - set coredump elf information
|
|
* @rproc: handle of a remote processor
|
|
* @class: elf class for coredump elf file
|
|
* @machine: elf machine for coredump elf file
|
|
*
|
|
* Set elf information which will be used for coredump elf file.
|
|
*
|
|
* Return: 0 on success, negative errno on error.
|
|
*/
|
|
int rproc_coredump_set_elf_info(struct rproc *rproc, u8 class, u16 machine)
|
|
{
|
|
if (class != ELFCLASS64 && class != ELFCLASS32)
|
|
return -EINVAL;
|
|
|
|
rproc->elf_class = class;
|
|
rproc->elf_machine = machine;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(rproc_coredump_set_elf_info);
|
|
|
|
static void rproc_coredump_free(void *data)
|
|
{
|
|
struct rproc_coredump_state *dump_state = data;
|
|
|
|
vfree(dump_state->header);
|
|
complete(&dump_state->dump_done);
|
|
}
|
|
|
|
static void *rproc_coredump_find_segment(loff_t user_offset,
|
|
struct list_head *segments,
|
|
size_t *data_left)
|
|
{
|
|
struct rproc_dump_segment *segment;
|
|
|
|
list_for_each_entry(segment, segments, node) {
|
|
if (user_offset < segment->size) {
|
|
*data_left = segment->size - user_offset;
|
|
return segment;
|
|
}
|
|
user_offset -= segment->size;
|
|
}
|
|
|
|
*data_left = 0;
|
|
return NULL;
|
|
}
|
|
|
|
static void rproc_copy_segment(struct rproc *rproc, void *dest,
|
|
struct rproc_dump_segment *segment,
|
|
size_t offset, size_t size)
|
|
{
|
|
void *ptr;
|
|
|
|
if (segment->dump) {
|
|
segment->dump(rproc, segment, dest, offset, size);
|
|
} else {
|
|
ptr = rproc_da_to_va(rproc, segment->da + offset, size);
|
|
if (!ptr) {
|
|
dev_err(&rproc->dev,
|
|
"invalid copy request for segment %pad with offset %zu and size %zu)\n",
|
|
&segment->da, offset, size);
|
|
memset(dest, 0xff, size);
|
|
} else {
|
|
memcpy(dest, ptr, size);
|
|
}
|
|
}
|
|
}
|
|
|
|
static ssize_t rproc_coredump_read(char *buffer, loff_t offset, size_t count,
|
|
void *data, size_t header_sz)
|
|
{
|
|
size_t seg_data, bytes_left = count;
|
|
ssize_t copy_sz;
|
|
struct rproc_dump_segment *seg;
|
|
struct rproc_coredump_state *dump_state = data;
|
|
struct rproc *rproc = dump_state->rproc;
|
|
void *elfcore = dump_state->header;
|
|
|
|
/* Copy the vmalloc'ed header first. */
|
|
if (offset < header_sz) {
|
|
copy_sz = memory_read_from_buffer(buffer, count, &offset,
|
|
elfcore, header_sz);
|
|
|
|
return copy_sz;
|
|
}
|
|
|
|
/*
|
|
* Find out the segment memory chunk to be copied based on offset.
|
|
* Keep copying data until count bytes are read.
|
|
*/
|
|
while (bytes_left) {
|
|
seg = rproc_coredump_find_segment(offset - header_sz,
|
|
&rproc->dump_segments,
|
|
&seg_data);
|
|
/* EOF check */
|
|
if (!seg) {
|
|
dev_info(&rproc->dev, "Ramdump done, %lld bytes read",
|
|
offset);
|
|
break;
|
|
}
|
|
|
|
copy_sz = min_t(size_t, bytes_left, seg_data);
|
|
|
|
rproc_copy_segment(rproc, buffer, seg, seg->size - seg_data,
|
|
copy_sz);
|
|
|
|
offset += copy_sz;
|
|
buffer += copy_sz;
|
|
bytes_left -= copy_sz;
|
|
}
|
|
|
|
return count - bytes_left;
|
|
}
|
|
|
|
/**
|
|
* rproc_coredump() - perform coredump
|
|
* @rproc: rproc handle
|
|
*
|
|
* This function will generate an ELF header for the registered segments
|
|
* and create a devcoredump device associated with rproc. Based on the
|
|
* coredump configuration this function will directly copy the segments
|
|
* from device memory to userspace or copy segments from device memory to
|
|
* a separate buffer, which can then be read by userspace.
|
|
* The first approach avoids using extra vmalloc memory. But it will stall
|
|
* recovery flow until dump is read by userspace.
|
|
*/
|
|
void rproc_coredump(struct rproc *rproc)
|
|
{
|
|
struct rproc_dump_segment *segment;
|
|
void *phdr;
|
|
void *ehdr;
|
|
size_t data_size;
|
|
size_t offset;
|
|
void *data;
|
|
u8 class = rproc->elf_class;
|
|
int phnum = 0;
|
|
struct rproc_coredump_state dump_state;
|
|
enum rproc_dump_mechanism dump_conf = rproc->dump_conf;
|
|
|
|
if (list_empty(&rproc->dump_segments) ||
|
|
dump_conf == RPROC_COREDUMP_DISABLED)
|
|
return;
|
|
|
|
if (class == ELFCLASSNONE) {
|
|
dev_err(&rproc->dev, "Elf class is not set\n");
|
|
return;
|
|
}
|
|
|
|
data_size = elf_size_of_hdr(class);
|
|
list_for_each_entry(segment, &rproc->dump_segments, node) {
|
|
/*
|
|
* For default configuration buffer includes headers & segments.
|
|
* For inline dump buffer just includes headers as segments are
|
|
* directly read from device memory.
|
|
*/
|
|
data_size += elf_size_of_phdr(class);
|
|
if (dump_conf == RPROC_COREDUMP_ENABLED)
|
|
data_size += segment->size;
|
|
|
|
phnum++;
|
|
}
|
|
|
|
data = vmalloc(data_size);
|
|
if (!data)
|
|
return;
|
|
|
|
ehdr = data;
|
|
|
|
memset(ehdr, 0, elf_size_of_hdr(class));
|
|
/* e_ident field is common for both elf32 and elf64 */
|
|
elf_hdr_init_ident(ehdr, class);
|
|
|
|
elf_hdr_set_e_type(class, ehdr, ET_CORE);
|
|
elf_hdr_set_e_machine(class, ehdr, rproc->elf_machine);
|
|
elf_hdr_set_e_version(class, ehdr, EV_CURRENT);
|
|
elf_hdr_set_e_entry(class, ehdr, rproc->bootaddr);
|
|
elf_hdr_set_e_phoff(class, ehdr, elf_size_of_hdr(class));
|
|
elf_hdr_set_e_ehsize(class, ehdr, elf_size_of_hdr(class));
|
|
elf_hdr_set_e_phentsize(class, ehdr, elf_size_of_phdr(class));
|
|
elf_hdr_set_e_phnum(class, ehdr, phnum);
|
|
|
|
phdr = data + elf_hdr_get_e_phoff(class, ehdr);
|
|
offset = elf_hdr_get_e_phoff(class, ehdr);
|
|
offset += elf_size_of_phdr(class) * elf_hdr_get_e_phnum(class, ehdr);
|
|
|
|
list_for_each_entry(segment, &rproc->dump_segments, node) {
|
|
memset(phdr, 0, elf_size_of_phdr(class));
|
|
elf_phdr_set_p_type(class, phdr, PT_LOAD);
|
|
elf_phdr_set_p_offset(class, phdr, offset);
|
|
elf_phdr_set_p_vaddr(class, phdr, segment->da);
|
|
elf_phdr_set_p_paddr(class, phdr, segment->da);
|
|
elf_phdr_set_p_filesz(class, phdr, segment->size);
|
|
elf_phdr_set_p_memsz(class, phdr, segment->size);
|
|
elf_phdr_set_p_flags(class, phdr, PF_R | PF_W | PF_X);
|
|
elf_phdr_set_p_align(class, phdr, 0);
|
|
|
|
if (dump_conf == RPROC_COREDUMP_ENABLED)
|
|
rproc_copy_segment(rproc, data + offset, segment, 0,
|
|
segment->size);
|
|
|
|
offset += elf_phdr_get_p_filesz(class, phdr);
|
|
phdr += elf_size_of_phdr(class);
|
|
}
|
|
if (dump_conf == RPROC_COREDUMP_ENABLED) {
|
|
dev_coredumpv(&rproc->dev, data, data_size, GFP_KERNEL);
|
|
return;
|
|
}
|
|
|
|
/* Initialize the dump state struct to be used by rproc_coredump_read */
|
|
dump_state.rproc = rproc;
|
|
dump_state.header = data;
|
|
init_completion(&dump_state.dump_done);
|
|
|
|
dev_coredumpm(&rproc->dev, NULL, &dump_state, data_size, GFP_KERNEL,
|
|
rproc_coredump_read, rproc_coredump_free);
|
|
|
|
/*
|
|
* Wait until the dump is read and free is called. Data is freed
|
|
* by devcoredump framework automatically after 5 minutes.
|
|
*/
|
|
wait_for_completion(&dump_state.dump_done);
|
|
}
|