Extend coredump functionality
v3 cover Extend coredump functionality
This patch series moves the coredump functionality to a separate file and adds "inline" coredump feature. Inline coredump directly copies segments from device memory during coredump to userspace. This avoids extra memory usage at the cost of speed. Recovery is stalled untill all data is read by userspace.
Changelog:
v3 -> v2:
- Move entire coredump functionality to remoteproc_coredump.c
- Modify rproc_coredump to perform dump according to conf. set by userspace
- Move the userspace configuration to debugfs from sysfs.
- Keep the default coredump implementation as is
v2 -> v1:
- Introduce new file for coredump.
- Add userspace sysfs configuration for dump type.
Rishabh Bhatnagar (3):
remoteproc: Move coredump functionality to a new file
remoteproc: Add inline coredump functionality
remoteproc: Add coredump debugfs entry
drivers/remoteproc/Makefile | 1 + drivers/remoteproc/remoteproc_core.c | 191 ------------------ drivers/remoteproc/remoteproc_coredump.c | 322 +++++++++++++++++++++++++++++++ drivers/remoteproc/remoteproc_debugfs.c | 86 +++++++++ drivers/remoteproc/remoteproc_internal.h | 4 + include/linux/remoteproc.h | 15 ++ 6 files changed, 428 insertions(+), 191 deletions(-) create mode 100644 drivers/remoteproc/remoteproc_coredump.c
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
PATCH v3 1/3 remoteproc: Move coredump functionality to a new file
Move all coredump functionality to an individual file. This is being done so that the current functionality can be extended in future patchsets.
--- drivers/remoteproc/Makefile | 1 + drivers/remoteproc/remoteproc_core.c | 191 ----------------------------- drivers/remoteproc/remoteproc_coredump.c | 204 +++++++++++++++++++++++++++++++ drivers/remoteproc/remoteproc_internal.h | 4 + 4 files changed, 209 insertions(+), 191 deletions(-) create mode 100644 drivers/remoteproc/remoteproc_coredump.c
drivers/remoteproc/Makefile +1 -0
@@ -5,6 +5,7 @@ obj-$(CONFIG_REMOTEPROC) += remoteproc.o remoteproc-y := remoteproc_core.o +remoteproc-y += remoteproc_coredump.o remoteproc-y += remoteproc_debugfs.o remoteproc-y += remoteproc_sysfs.o remoteproc-y += remoteproc_virtio.o
drivers/remoteproc/remoteproc_core.c +0 -191
215 lines not on this page · raw message
drivers/remoteproc/remoteproc_coredump.c new file +204 -0
204 lines not on this page · raw message
drivers/remoteproc/remoteproc_internal.h +4 -0
@@ -47,6 +47,10 @@ struct dentry *rproc_create_trace_file(const char *name, struct rproc *rproc,int rproc_init_sysfs (void );void rproc_exit_sysfs (void ); +/* from remoteproc_coredump.c */ +void rproc_coredump_cleanup (struct rproc *rproc); +void rproc_coredump (struct rproc *rproc); +void rproc_free_vring (struct rproc_vring *rvring);int rproc_alloc_vring (struct rproc_vdev *rvdev,int i);
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v3 1/3] remoteproc: Move coredump functionality to a new file
Quoted 4 lines · Rishabh Bhatnagar
Move all coredump functionality to an individual file. This is being done so that the current functionality can be extended in future patchsets.
Thanks,
Bjorn
Quoted 472 lines
Signed-off-by Rishabh Bhatnagar <[email protected]>--- drivers/remoteproc/Makefile | 1 + drivers/remoteproc/remoteproc_core.c | 191 ----------------------------- drivers/remoteproc/remoteproc_coredump.c | 204 +++++++++++++++++++++++++++++++ drivers/remoteproc/remoteproc_internal.h | 4 + 4 files changed, 209 insertions(+), 191 deletions(-) create mode 100644 drivers/remoteproc/remoteproc_coredump.cdrivers/remoteproc/Makefile +1
-0@@ -5,6 +5,7 @@ obj-$(CONFIG_REMOTEPROC) += remoteproc.o remoteproc-y := remoteproc_core.o +remoteproc-y += remoteproc_coredump.o remoteproc-y += remoteproc_debugfs.o remoteproc-y += remoteproc_sysfs.o remoteproc-y += remoteproc_virtio.odrivers/remoteproc/remoteproc_core.c +0
-191@@ -26,7 +26,6 @@#include <linux/firmware.h> #include <linux/string.h> #include <linux/debugfs.h> -#include <linux/devcoredump.h> #include <linux/rculist.h> #include <linux/remoteproc.h> #include <linux/iommu.h> @@ -40,7 +39,6 @@#include <linux/platform_device.h> #include "remoteproc_internal.h" -#include "remoteproc_elf_helpers.h" #define HIGH_BITS_MASK 0xFFFFFFFF00000000ULL@@ -1238,19 +1236,6 @@ static int rproc_alloc_registered_carveouts(struct rproc *rproc)return 0 ; } -/** -* rproc_coredump_cleanup() - clean up dump_segments list -* @rproc: the remote processor handle -*/ -static 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_resource_cleanup() - clean up and free all acquired resources @@ -1509,182 +1494,6 @@ static int rproc_stop(struct rproc *rproc, bool crashed)return 0 ; } -/** -* 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), -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); - -/** -* 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. -*/ -static void rproc_coredump (struct rproc *rproc) -{ -struct rproc_dump_segment *segment; -void *phdr; -void *ehdr; -size_t data_size; -size_t offset; -void *data; -void *ptr; -u8 class = rproc->elf_class; -int phnum =0 ; - -if (list_empty (&rproc->dump_segments)) -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) { - data_size +=elf_size_of_phdr (class) + 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 (segment->dump) { - segment->dump (rproc, segment, data + offset); - }else { - ptr =rproc_da_to_va (rproc, segment->da, segment->size); -if (!ptr) { -dev_err (&rproc->dev, -"invalid coredump segment (%pad, %zu)\n" , - &segment->da, segment->size); -memset (data + offset,0xff , segment->size); - }else { -memcpy (data + offset, ptr, segment->size); - } - } - - offset +=elf_phdr_get_p_filesz (class, phdr); - phdr +=elf_size_of_phdr (class); - } - -dev_coredumpv (&rproc->dev, data, data_size,GFP_KERNEL ); -}/** * rproc_trigger_recovery() - recover a remoteproc drivers/remoteproc/remoteproc_coredump.c new file +204
-0@@ -0,0 +1,204 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Coredump functionality for Remoteproc framework. +* +* Copyright (c) 2020, The Linux Foundation. All rights reserved. +*/ + +#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" + +/** +* 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), +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); + +/** +* 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. +*/ +void rproc_coredump (struct rproc *rproc) +{ +struct rproc_dump_segment *segment; +void *phdr; +void *ehdr; +size_t data_size; +size_t offset; +void *data; +void *ptr; +u8 class = rproc->elf_class; +int phnum =0 ; + +if (list_empty (&rproc->dump_segments)) +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) { + data_size +=elf_size_of_phdr (class) + 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 (segment->dump) { + segment->dump (rproc, segment, data + offset); + }else { + ptr =rproc_da_to_va (rproc, segment->da, segment->size); +if (!ptr) { +dev_err (&rproc->dev, +"invalid coredump segment (%pad, %zu)\n" , + &segment->da, segment->size); +memset (data + offset,0xff , segment->size); + }else { +memcpy (data + offset, ptr, segment->size); + } + } + + offset +=elf_phdr_get_p_filesz (class, phdr); + phdr +=elf_size_of_phdr (class); + } + +dev_coredumpv (&rproc->dev, data, data_size,GFP_KERNEL ); +}drivers/remoteproc/remoteproc_internal.h +4
-0@@ -47,6 +47,10 @@ struct dentry *rproc_create_trace_file(const char *name, struct rproc *rproc,int rproc_init_sysfs (void );void rproc_exit_sysfs (void ); +/* from remoteproc_coredump.c */ +void rproc_coredump_cleanup (struct rproc *rproc); +void rproc_coredump (struct rproc *rproc); +void rproc_free_vring (struct rproc_vring *rvring);int rproc_alloc_vring (struct rproc_vdev *rvdev,int i);Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v3 1/3] remoteproc: Move coredump functionality to a new file
In reply to Rishabh BhatnagarQuoted 4 lines · Rishabh Bhatnagar
Move all coredump functionality to an individual file. This is being done so that the current functionality can be extended in future patchsets.
Quoted 9 lines
Signed-off-by Rishabh Bhatnagar <[email protected]>--- drivers/remoteproc/Makefile | 1 + drivers/remoteproc/remoteproc_core.c | 191 ----------------------------- drivers/remoteproc/remoteproc_coredump.c | 204 +++++++++++++++++++++++++++++++ drivers/remoteproc/remoteproc_internal.h | 4 + 4 files changed, 209 insertions(+), 191 deletions(-) create mode 100644 drivers/remoteproc/remoteproc_coredump.c
Quoted 463 lines
drivers/remoteproc/Makefile +1
-0@@ -5,6 +5,7 @@ obj-$(CONFIG_REMOTEPROC) += remoteproc.o remoteproc-y := remoteproc_core.o +remoteproc-y += remoteproc_coredump.o remoteproc-y += remoteproc_debugfs.o remoteproc-y += remoteproc_sysfs.o remoteproc-y += remoteproc_virtio.odrivers/remoteproc/remoteproc_core.c +0
-191@@ -26,7 +26,6 @@#include <linux/firmware.h> #include <linux/string.h> #include <linux/debugfs.h> -#include <linux/devcoredump.h> #include <linux/rculist.h> #include <linux/remoteproc.h> #include <linux/iommu.h> @@ -40,7 +39,6 @@#include <linux/platform_device.h> #include "remoteproc_internal.h" -#include "remoteproc_elf_helpers.h" #define HIGH_BITS_MASK 0xFFFFFFFF00000000ULL@@ -1238,19 +1236,6 @@ static int rproc_alloc_registered_carveouts(struct rproc *rproc)return 0 ; } -/** -* rproc_coredump_cleanup() - clean up dump_segments list -* @rproc: the remote processor handle -*/ -static 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_resource_cleanup() - clean up and free all acquired resources @@ -1509,182 +1494,6 @@ static int rproc_stop(struct rproc *rproc, bool crashed)return 0 ; } -/** -* 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), -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); - -/** -* 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. -*/ -static void rproc_coredump (struct rproc *rproc) -{ -struct rproc_dump_segment *segment; -void *phdr; -void *ehdr; -size_t data_size; -size_t offset; -void *data; -void *ptr; -u8 class = rproc->elf_class; -int phnum =0 ; - -if (list_empty (&rproc->dump_segments)) -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) { - data_size +=elf_size_of_phdr (class) + 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 (segment->dump) { - segment->dump (rproc, segment, data + offset); - }else { - ptr =rproc_da_to_va (rproc, segment->da, segment->size); -if (!ptr) { -dev_err (&rproc->dev, -"invalid coredump segment (%pad, %zu)\n" , - &segment->da, segment->size); -memset (data + offset,0xff , segment->size); - }else { -memcpy (data + offset, ptr, segment->size); - } - } - - offset +=elf_phdr_get_p_filesz (class, phdr); - phdr +=elf_size_of_phdr (class); - } - -dev_coredumpv (&rproc->dev, data, data_size,GFP_KERNEL ); -}/** * rproc_trigger_recovery() - recover a remoteproc drivers/remoteproc/remoteproc_coredump.c new file +204
-0@@ -0,0 +1,204 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Coredump functionality for Remoteproc framework. +* +* Copyright (c) 2020, The Linux Foundation. All rights reserved. +*/ + +#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" + +/** +* 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), +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); + +/** +* 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. +*/ +void rproc_coredump (struct rproc *rproc) +{ +struct rproc_dump_segment *segment; +void *phdr; +void *ehdr; +size_t data_size; +size_t offset; +void *data; +void *ptr; +u8 class = rproc->elf_class; +int phnum =0 ; + +if (list_empty (&rproc->dump_segments)) +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) { + data_size +=elf_size_of_phdr (class) + 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 (segment->dump) { + segment->dump (rproc, segment, data + offset); + }else { + ptr =rproc_da_to_va (rproc, segment->da, segment->size); +if (!ptr) { +dev_err (&rproc->dev, +"invalid coredump segment (%pad, %zu)\n" , + &segment->da, segment->size); +memset (data + offset,0xff , segment->size); + }else { +memcpy (data + offset, ptr, segment->size); + } + } + + offset +=elf_phdr_get_p_filesz (class, phdr); + phdr +=elf_size_of_phdr (class); + } + +dev_coredumpv (&rproc->dev, data, data_size,GFP_KERNEL ); +}drivers/remoteproc/remoteproc_internal.h +4
-0@@ -47,6 +47,10 @@ struct dentry *rproc_create_trace_file(const char *name, struct rproc *rproc,int rproc_init_sysfs (void );void rproc_exit_sysfs (void ); +/* from remoteproc_coredump.c */ +void rproc_coredump_cleanup (struct rproc *rproc); +void rproc_coredump (struct rproc *rproc); +void rproc_free_vring (struct rproc_vring *rvring);int rproc_alloc_vring (struct rproc_vdev *rvdev,int i);Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
PATCH v3 2/3 remoteproc: Add inline coredump functionality
In reply to Rishabh BhatnagarThe current coredump implementation uses vmalloc area to copy all the segments. But this might put strain on low memory targets as the firmware size sometimes is in tens of MBs. The situation becomes worse if there are multiple remote processors undergoing recovery at the same time. This patch adds inline coredump functionality that avoids extra memory usage. This requires recovery to be halted until data is read by userspace and free function is called.
--- drivers/remoteproc/remoteproc_coredump.c | 129 +++++++++++++++++++++++++++++-- include/linux/remoteproc.h | 15 ++++ 2 files changed, 139 insertions(+), 5 deletions(-)
drivers/remoteproc/remoteproc_coredump.c +124 -5
@@ -12,6 +12,12 @@#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
@@ -114,12 +120,96 @@ int rproc_coredump_set_elf_info(struct rproc *rproc, u8 class, u16 machine) }EXPORT_SYMBOL (rproc_coredump_set_elf_info); +static void rproc_coredump_free (void *data) +{ +struct rproc_coredump_state *dump_state = data; + +complete (&dump_state->dump_done); +vfree (dump_state->header); +} + +static unsigned long 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->da + user_offset; + } + user_offset -= segment->size; + } + + *data_left =0 ; +return 0 ; +} + +static ssize_t rproc_coredump_read (char *buffer,loff_t offset,size_t count, +void *data,size_t header_sz) +{ +void *device_mem; +size_t seg_data; +size_t copy_sz, bytes_left = count; +unsigned long addr; +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); +if (copy_sz <0 ) +return -EINVAL ; + +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) { + addr =rproc_coredump_find_segment (offset - header_sz, + &rproc->dump_segments, + &seg_data); +/* EOF check */ +if (seg_data ==0 ) { +dev_info (&rproc->dev,"Ramdump done, %lld bytes read" , + offset); +break ; + } + + copy_sz =min_t (size_t, bytes_left, seg_data); + + device_mem =rproc_da_to_va (rproc, addr, copy_sz); +if (!device_mem) { +dev_err (&rproc->dev,"Coredump: %lx with size %zd out of remoteproc carveout\n" , + addr, copy_sz); +return -ENOMEM ; + } +memcpy (buffer, device_mem, 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. +* 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) {
@@ -132,8 +222,10 @@ void rproc_coredump(struct rproc *rproc)void *ptr;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)) +if (list_empty (&rproc->dump_segments) || dump_conf ==COREDUMP_DISABLED )return ;if (class ==ELFCLASSNONE ) {
@@ -143,7 +235,14 @@ void rproc_coredump(struct rproc *rproc) data_size =elf_size_of_hdr (class);list_for_each_entry (segment, &rproc->dump_segments, node) { - data_size +=elf_size_of_phdr (class) + segment->size; + +/* 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 ==COREDUMP_DEFAULT ) + data_size += segment->size; phnum++; }
@@ -182,6 +281,10 @@ void rproc_coredump(struct rproc *rproc)elf_phdr_set_p_flags (class, phdr,PF_R |PF_W |PF_X );elf_phdr_set_p_align (class, phdr,0 ); +/* No need to copy segments for inline dumps */ +if (dump_conf ==COREDUMP_INLINE ) + goto next_seg; +if (segment->dump) { segment->dump (rproc, segment, data + offset); }else {
@@ -195,10 +298,26 @@ void rproc_coredump(struct rproc *rproc)memcpy (data + offset, ptr, segment->size); } } - +next_seg: offset +=elf_phdr_get_p_filesz (class, phdr); phdr +=elf_size_of_phdr (class); } -dev_coredumpv (&rproc->dev, data, data_size,GFP_KERNEL ); +if (dump_conf ==COREDUMP_DEFAULT ) { +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); }
include/linux/remoteproc.h +15 -0
@@ -435,6 +435,19 @@ enum rproc_crash_type { };/** +* enum rproc_dump_mechanism - Coredump options for core +* @COREDUMP_DEFAULT: Copy dump to separate buffer and carry on with recovery +* @COREDUMP_INLINE: Read segments directly from device memory. Stall +recovery until all segments are read +* @COREDUMP_DISABLED: Don't perform any dump +*/ +enum rproc_dump_mechanism { +COREDUMP_DEFAULT , +COREDUMP_INLINE , +COREDUMP_DISABLED , +}; + +/** * struct rproc_dump_segment - segment info from ELF header * @node: list node related to the rproc segment list * @da: device address of the segment
@@ -466,6 +479,7 @@ struct rproc_dump_segment {* @dev: virtual device for refcounting and common remoteproc behavior * @power: refcount of users who need this rproc powered up * @state: state of the device +* @dump_conf: Currenlty selected coredump configuration * @lock: lock which protects concurrent manipulations of the rproc * @dbg_dir: debugfs directory of this rproc device * @traces: list of trace buffers
@@ -499,6 +513,7 @@ struct rproc {struct device dev;atomic_t power;unsigned int state; +enum rproc_dump_mechanism dump_conf;struct mutex lock;struct dentry *dbg_dir;struct list_head traces;
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v3 2/3] remoteproc: Add inline coredump functionality
Quoted 9 lines · Rishabh Bhatnagar
The current coredump implementation uses vmalloc area to copy all the segments. But this might put strain on low memory targets as the firmware size sometimes is in tens of MBs. The situation becomes worse if there are multiple remote processors undergoing recovery at the same time. This patch adds inline coredump functionality that avoids extra memory usage. This requires recovery to be halted until data is read by userspace and free function is called.
Overall I think this looks really good now, but I spotted an issue with INLINE dumps not using segment->dump().
Also there's 3 checkpatch --strict warnings, please fix those.
Quoted 7 lines
Signed-off-by Rishabh Bhatnagar <[email protected]>--- drivers/remoteproc/remoteproc_coredump.c | 129 +++++++++++++++++++++++++++++-- include/linux/remoteproc.h | 15 ++++ 2 files changed, 139 insertions(+), 5 deletions(-)drivers/remoteproc/remoteproc_coredump.c +0
-0
[..]
Quoted 14 lines
drivers/remoteproc/remoteproc_coredump.c +14
-0+static ssize_t rproc_coredump_read (char *buffer,loff_t offset,size_t count, +void *data,size_t header_sz) +{ +void *device_mem; +size_t seg_data; +size_t copy_sz, bytes_left = count; +unsigned long addr; +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,
drivers/remoteproc/remoteproc_coredump.c int rproc_coredump_set_elf_info(struct rproc *rproc, u8 class, u16 machine) · line 172
Quoted 10 lines
drivers/remoteproc/remoteproc_coredump.c +10
-0+ elfcore, header_sz); +if (copy_sz <0 ) +return -EINVAL ; + +return copy_sz; + } + +/* Find out the segment memory chunk to be copied based on offset. +* Keep copying data until count bytes are read. +*/
/* * Multiline comments start on the second line throughout * remoteproc, please follow this. */
Quoted 8 lines
drivers/remoteproc/remoteproc_coredump.c +8
-0+while (bytes_left) { + addr =rproc_coredump_find_segment (offset - header_sz, + &rproc->dump_segments, + &seg_data); +/* EOF check */ +if (seg_data ==0 ) { +dev_info (&rproc->dev,"Ramdump done, %lld bytes read" , + offset);
drivers/remoteproc/remoteproc_coredump.c int rproc_coredump_set_elf_info(struct rproc *rproc, u8 class, u16 machine) · line 190
Quoted 10 lines
drivers/remoteproc/remoteproc_coredump.c +10
-0+break ; + } + + copy_sz =min_t (size_t, bytes_left, seg_data); + + device_mem =rproc_da_to_va (rproc, addr, copy_sz); +if (!device_mem) { +dev_err (&rproc->dev,"Coredump: %lx with size %zd out of remoteproc carveout\n" , + addr, copy_sz); +return -ENOMEM ;
I think it would be best to maintain the same behavior between INLINE and DEFAULT here.
drivers/remoteproc/remoteproc_coredump.c
Quoted 2 lines
drivers/remoteproc/remoteproc_coredump.c +2
-0+ } +memcpy (buffer, device_mem, copy_sz);
This won't work for modem on e.g. SDM845, because we need to do some special tricks to make the memory readable, that's why we invoke segment->dump() in the DEFAULT scenario. Doing a memcpy here instead will result in a security violation.
Perhaps this snippet can be extracted to a separate helper function, which would allow you to avoid the next_seg goto label below.
Quoted 8 lines
drivers/remoteproc/remoteproc_coredump.c +8
-0+ + offset += copy_sz; + buffer += copy_sz; + bytes_left -= copy_sz; + } + +return count - bytes_left; +}
[..]
Quoted 8 lines
include/linux/remoteproc.h +0
-0@@ -435,6 +435,19 @@ enum rproc_crash_type { };/**
include/linux/remoteproc.h enum rproc_crash_type { · line 447
Quoted 10 lines
include/linux/remoteproc.h +10
-0+* enum rproc_dump_mechanism - Coredump options for core +* @COREDUMP_DEFAULT: Copy dump to separate buffer and carry on with recovery +* @COREDUMP_INLINE: Read segments directly from device memory. Stall +recovery until all segments are read +* @COREDUMP_DISABLED: Don't perform any dump +*/ +enum rproc_dump_mechanism { +COREDUMP_DEFAULT , +COREDUMP_INLINE , +COREDUMP_DISABLED ,
Please prefix these with RPROC_, as "coredump" has a meaning outside remoteproc as well.
Regards,
Bjorn
Re: [PATCH v3 2/3] remoteproc: Add inline coredump functionality
In reply to Rishabh BhatnagarHi Rishab,
Quoted 20 lines · Rishabh Bhatnagar
The current coredump implementation uses vmalloc area to copy all the segments. But this might put strain on low memory targets as the firmware size sometimes is in tens of MBs. The situation becomes worse if there are multiple remote processors undergoing recovery at the same time. This patch adds inline coredump functionality that avoids extra memory usage. This requires recovery to be halted until data is read by userspace and free function is called.
Signed-off-by Rishabh Bhatnagar <[email protected]>--- drivers/remoteproc/remoteproc_coredump.c | 129 +++++++++++++++++++++++++++++-- include/linux/remoteproc.h | 15 ++++ 2 files changed, 139 insertions(+), 5 deletions(-)drivers/remoteproc/remoteproc_coredump.c +0
-0
drivers/remoteproc/remoteproc_coredump.c line 20
Quoted 9 lines
drivers/remoteproc/remoteproc_coredump.c +6
-0@@ -12,6 +12,12 @@#include "remoteproc_internal.h" #include "remoteproc_elf_helpers.h" +struct rproc_coredump_state { +struct rproc *rproc; +void *header; +struct completion dump_done; +}; +
To use struct completion and related function linux/completion.h needs to be included.
Quoted 47 lines
drivers/remoteproc/remoteproc_coredump.c +40
-0/** * rproc_coredump_cleanup() - clean up dump_segments list * @rproc: the remote processor handle @@ -114,12 +120,96 @@ int rproc_coredump_set_elf_info(struct rproc *rproc, u8 class, u16 machine) }EXPORT_SYMBOL (rproc_coredump_set_elf_info); +static void rproc_coredump_free (void *data) +{ +struct rproc_coredump_state *dump_state = data; + +complete (&dump_state->dump_done); +vfree (dump_state->header); +} + +static unsigned long 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->da + user_offset; + } + user_offset -= segment->size; + } + + *data_left =0 ; +return 0 ; +} + +static ssize_t rproc_coredump_read (char *buffer,loff_t offset,size_t count, +void *data,size_t header_sz) +{ +void *device_mem; +size_t seg_data; +size_t copy_sz, bytes_left = count; +unsigned long addr; +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,
drivers/remoteproc/remoteproc_coredump.c int rproc_coredump_set_elf_info(struct rproc *rproc, u8 class, u16 machine) · line 172
Quoted 10 lines
drivers/remoteproc/remoteproc_coredump.c +10
-0+ elfcore, header_sz); +if (copy_sz <0 ) +return -EINVAL ; + +return copy_sz; + } + +/* Find out the segment memory chunk to be copied based on offset. +* Keep copying data until count bytes are read. +*/
Wrong format for multi-line comment, the following is the standard format:
/*
* Find out the segment memory chunk to be copied based on offset.
* Keep copying data until count bytes are read.
*/
Quoted 57 lines
drivers/remoteproc/remoteproc_coredump.c +38
-2+while (bytes_left) { + addr =rproc_coredump_find_segment (offset - header_sz, + &rproc->dump_segments, + &seg_data); +/* EOF check */ +if (seg_data ==0 ) { +dev_info (&rproc->dev,"Ramdump done, %lld bytes read" , + offset); +break ; + } + + copy_sz =min_t (size_t, bytes_left, seg_data); + + device_mem =rproc_da_to_va (rproc, addr, copy_sz); +if (!device_mem) { +dev_err (&rproc->dev,"Coredump: %lx with size %zd out of remoteproc carveout\n" , + addr, copy_sz); +return -ENOMEM ; + } +memcpy (buffer, device_mem, 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. +* 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) {@@ -132,8 +222,10 @@ void rproc_coredump(struct rproc *rproc)void *ptr;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)) +if (list_empty (&rproc->dump_segments) || dump_conf ==COREDUMP_DISABLED )return ;if (class ==ELFCLASSNONE ) {
drivers/remoteproc/remoteproc_coredump.c void rproc_coredump(struct rproc *rproc) · line 242
Quoted 9 lines
drivers/remoteproc/remoteproc_coredump.c +5
-1@@ -143,7 +235,14 @@ void rproc_coredump(struct rproc *rproc) data_size =elf_size_of_hdr (class);list_for_each_entry (segment, &rproc->dump_segments, node) { - data_size +=elf_size_of_phdr (class) + segment->size; + +/* For default configuration buffer includes headers & segments. +* For inline dump buffer just includes headers as segments are +* directly read from device memory. +*/
Same
Quoted 34 lines
drivers/remoteproc/remoteproc_coredump.c +14
-2+ data_size +=elf_size_of_phdr (class); +if (dump_conf ==COREDUMP_DEFAULT ) + data_size += segment->size; phnum++; }@@ -182,6 +281,10 @@ void rproc_coredump(struct rproc *rproc)elf_phdr_set_p_flags (class, phdr,PF_R |PF_W |PF_X );elf_phdr_set_p_align (class, phdr,0 ); +/* No need to copy segments for inline dumps */ +if (dump_conf ==COREDUMP_INLINE ) + goto next_seg; +if (segment->dump) { segment->dump (rproc, segment, data + offset); }else {@@ -195,10 +298,26 @@ void rproc_coredump(struct rproc *rproc)memcpy (data + offset, ptr, segment->size); } } - +next_seg: offset +=elf_phdr_get_p_filesz (class, phdr); phdr +=elf_size_of_phdr (class); } -dev_coredumpv (&rproc->dev, data, data_size,GFP_KERNEL ); +if (dump_conf ==COREDUMP_DEFAULT ) { +dev_coredumpv (&rproc->dev, data, data_size,GFP_KERNEL ); +return ; + } + +/* Initialize the dump state struct to be used by rproc_coredump_read */
drivers/remoteproc/remoteproc_coredump.c void rproc_coredump(struct rproc *rproc) · line 321
Quoted 10 lines
drivers/remoteproc/remoteproc_coredump.c +10
-0+ 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. +*/
Same
With the above:
Quoted 45 lines
drivers/remoteproc/remoteproc_coredump.c +1
-0+wait_for_completion (&dump_state.dump_done); }include/linux/remoteproc.h +15
-0@@ -435,6 +435,19 @@ enum rproc_crash_type { };/** +* enum rproc_dump_mechanism - Coredump options for core +* @COREDUMP_DEFAULT: Copy dump to separate buffer and carry on with recovery +* @COREDUMP_INLINE: Read segments directly from device memory. Stall +recovery until all segments are read +* @COREDUMP_DISABLED: Don't perform any dump +*/ +enum rproc_dump_mechanism { +COREDUMP_DEFAULT , +COREDUMP_INLINE , +COREDUMP_DISABLED , +}; + +/** * struct rproc_dump_segment - segment info from ELF header * @node: list node related to the rproc segment list * @da: device address of the segment @@ -466,6 +479,7 @@ struct rproc_dump_segment {* @dev: virtual device for refcounting and common remoteproc behavior * @power: refcount of users who need this rproc powered up * @state: state of the device +* @dump_conf: Currenlty selected coredump configuration * @lock: lock which protects concurrent manipulations of the rproc * @dbg_dir: debugfs directory of this rproc device * @traces: list of trace buffers @@ -499,6 +513,7 @@ struct rproc {struct device dev;atomic_t power;unsigned int state; +enum rproc_dump_mechanism dump_conf;struct mutex lock;struct dentry *dbg_dir;struct list_head traces;Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
PATCH v3 3/3 remoteproc: Add coredump debugfs entry
In reply to Rishabh BhatnagarAdd coredump debugfs entry to configure the type of dump that will be collected during recovery. User can select between default or inline coredump functionality. Also coredump collection can be disabled through this interface.
This functionality can be configured differently for different remote processors.
--- drivers/remoteproc/remoteproc_debugfs.c | 86 +++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+)
drivers/remoteproc/remoteproc_debugfs.c +86 -0
@@ -28,6 +28,90 @@static struct dentry *rproc_dbg;/* +* A coredump-configuration-to-string lookup table, for exposing a +* human readable configuration via debugfs. Always keep in sync with +* enum rproc_coredump_mechanism +*/ +static const char *const rproc_coredump_str[] = { + [COREDUMP_DEFAULT ] ="default" , + [COREDUMP_INLINE ] ="inline" , + [COREDUMP_DISABLED ] ="disabled" , +}; + +/* Expose the current coredump configuration via debugfs */ +static ssize_t rproc_coredump_read (struct file *filp,char __user *userbuf, +size_t count,loff_t *ppos) +{ +struct rproc *rproc = filp->private_data; +const char *buf = rproc_coredump_str[rproc->dump_conf]; + +return simple_read_from_buffer (userbuf, count, ppos, buf,strlen (buf)); +} + +/* +* By writing to the 'coredump' debugfs entry, we control the behavior of the +* coredump mechanism dynamically. The default value of this entry is "default". +* +* The 'coredump' debugfs entry supports these commands: +* +* default: This is the default coredump mechanism. When the remoteproc +* crashes the entire coredump will be copied to a separate buffer +* and exposed to userspace. +* +* inline: The coredump will not be copied to a separate buffer and the +* recovery process will have to wait until data is read by +* userspace. But this avoid usage of extra memory. +* +* disabled: This will disable coredump. Recovery will proceed without +* collecting any dump. +*/ +static ssize_t rproc_coredump_write (struct file *filp, +const char __user *user_buf,size_t count, +loff_t *ppos) +{ +struct rproc *rproc = filp->private_data; +int ret, err =0 ; +char buf[20 ]; + +if (count >sizeof (buf)) +return -EINVAL ; + + ret =copy_from_user (buf, user_buf, count); +if (ret) +return -EFAULT ; + +/* remove end of line */ +if (buf[count -1 ] =='\n' ) + buf[count -1 ] ='\0' ; + +if (rproc->state ==RPROC_CRASHED ) { +dev_err (&rproc->dev,"can't change coredump configuration\n" ); + err = -EBUSY ; + goto out; + } + +if (!strncmp (buf,"disable" , count)) + rproc->dump_conf =COREDUMP_DISABLED ; +else if (!strncmp (buf,"inline" , count)) + rproc->dump_conf =COREDUMP_INLINE ; +else if (!strncmp (buf,"default" , count)) + rproc->dump_conf =COREDUMP_DEFAULT ; +else { +dev_err (&rproc->dev,"Invalid coredump configuration\n" ); + err = -EINVAL ; + } +out: +return err ? err : count; +} + +static const struct file_operations rproc_coredump_fops = { + .read = rproc_coredump_read, + .write = rproc_coredump_write, + .open = simple_open, + .llseek = generic_file_llseek, +}; + +/* * Some remote processors may support dumping trace logs into a shared * memory buffer. We expose this trace buffer using debugfs, so users * can easily tell what's going on remotely.
@@ -337,6 +421,8 @@ void rproc_create_debug_dir(struct rproc *rproc) rproc, &rproc_rsc_table_fops);debugfs_create_file ("carveout_memories" ,0400 , rproc->dbg_dir, rproc, &rproc_carveouts_fops); +debugfs_create_file ("coredump" ,0600 , rproc->dbg_dir, + rproc, &rproc_coredump_fops); }void __init rproc_init_debugfs (void )
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v3 3/3] remoteproc: Add coredump debugfs entry
Quoted 7 lines · Rishabh Bhatnagar
Add coredump debugfs entry to configure the type of dump that will be collected during recovery. User can select between default or inline coredump functionality. Also coredump collection can be disabled through this interface.
This functionality can be configured differently for different remote processors.
Regards,
Bjorn
Quoted 112 lines
Signed-off-by Rishabh Bhatnagar <[email protected]>--- drivers/remoteproc/remoteproc_debugfs.c | 86 +++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+)drivers/remoteproc/remoteproc_debugfs.c +86
-0@@ -28,6 +28,90 @@static struct dentry *rproc_dbg;/* +* A coredump-configuration-to-string lookup table, for exposing a +* human readable configuration via debugfs. Always keep in sync with +* enum rproc_coredump_mechanism +*/ +static const char *const rproc_coredump_str[] = { + [COREDUMP_DEFAULT ] ="default" , + [COREDUMP_INLINE ] ="inline" , + [COREDUMP_DISABLED ] ="disabled" , +}; + +/* Expose the current coredump configuration via debugfs */ +static ssize_t rproc_coredump_read (struct file *filp,char __user *userbuf, +size_t count,loff_t *ppos) +{ +struct rproc *rproc = filp->private_data; +const char *buf = rproc_coredump_str[rproc->dump_conf]; + +return simple_read_from_buffer (userbuf, count, ppos, buf,strlen (buf)); +} + +/* +* By writing to the 'coredump' debugfs entry, we control the behavior of the +* coredump mechanism dynamically. The default value of this entry is "default". +* +* The 'coredump' debugfs entry supports these commands: +* +* default: This is the default coredump mechanism. When the remoteproc +* crashes the entire coredump will be copied to a separate buffer +* and exposed to userspace. +* +* inline: The coredump will not be copied to a separate buffer and the +* recovery process will have to wait until data is read by +* userspace. But this avoid usage of extra memory. +* +* disabled: This will disable coredump. Recovery will proceed without +* collecting any dump. +*/ +static ssize_t rproc_coredump_write (struct file *filp, +const char __user *user_buf,size_t count, +loff_t *ppos) +{ +struct rproc *rproc = filp->private_data; +int ret, err =0 ; +char buf[20 ]; + +if (count >sizeof (buf)) +return -EINVAL ; + + ret =copy_from_user (buf, user_buf, count); +if (ret) +return -EFAULT ; + +/* remove end of line */ +if (buf[count -1 ] =='\n' ) + buf[count -1 ] ='\0' ; + +if (rproc->state ==RPROC_CRASHED ) { +dev_err (&rproc->dev,"can't change coredump configuration\n" ); + err = -EBUSY ; + goto out; + } + +if (!strncmp (buf,"disable" , count)) + rproc->dump_conf =COREDUMP_DISABLED ; +else if (!strncmp (buf,"inline" , count)) + rproc->dump_conf =COREDUMP_INLINE ; +else if (!strncmp (buf,"default" , count)) + rproc->dump_conf =COREDUMP_DEFAULT ; +else { +dev_err (&rproc->dev,"Invalid coredump configuration\n" ); + err = -EINVAL ; + } +out: +return err ? err : count; +} + +static const struct file_operations rproc_coredump_fops = { + .read = rproc_coredump_read, + .write = rproc_coredump_write, + .open = simple_open, + .llseek = generic_file_llseek, +}; + +/* * Some remote processors may support dumping trace logs into a shared * memory buffer. We expose this trace buffer using debugfs, so users * can easily tell what's going on remotely. @@ -337,6 +421,8 @@ void rproc_create_debug_dir(struct rproc *rproc) rproc, &rproc_rsc_table_fops);debugfs_create_file ("carveout_memories" ,0400 , rproc->dbg_dir, rproc, &rproc_carveouts_fops); +debugfs_create_file ("coredump" ,0600 , rproc->dbg_dir, + rproc, &rproc_coredump_fops); }void __init rproc_init_debugfs (void )Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v3 3/3] remoteproc: Add coredump debugfs entry
In reply to Rishabh BhatnagarQuoted 108 lines · Rishabh Bhatnagar
Add coredump debugfs entry to configure the type of dump that will be collected during recovery. User can select between default or inline coredump functionality. Also coredump collection can be disabled through this interface.
This functionality can be configured differently for different remote processors.Signed-off-by Rishabh Bhatnagar <[email protected]>--- drivers/remoteproc/remoteproc_debugfs.c | 86 +++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+)drivers/remoteproc/remoteproc_debugfs.c +84
-0@@ -28,6 +28,90 @@static struct dentry *rproc_dbg;/* +* A coredump-configuration-to-string lookup table, for exposing a +* human readable configuration via debugfs. Always keep in sync with +* enum rproc_coredump_mechanism +*/ +static const char *const rproc_coredump_str[] = { + [COREDUMP_DEFAULT ] ="default" , + [COREDUMP_INLINE ] ="inline" , + [COREDUMP_DISABLED ] ="disabled" , +}; + +/* Expose the current coredump configuration via debugfs */ +static ssize_t rproc_coredump_read (struct file *filp,char __user *userbuf, +size_t count,loff_t *ppos) +{ +struct rproc *rproc = filp->private_data; +const char *buf = rproc_coredump_str[rproc->dump_conf]; + +return simple_read_from_buffer (userbuf, count, ppos, buf,strlen (buf)); +} + +/* +* By writing to the 'coredump' debugfs entry, we control the behavior of the +* coredump mechanism dynamically. The default value of this entry is "default". +* +* The 'coredump' debugfs entry supports these commands: +* +* default: This is the default coredump mechanism. When the remoteproc +* crashes the entire coredump will be copied to a separate buffer +* and exposed to userspace. +* +* inline: The coredump will not be copied to a separate buffer and the +* recovery process will have to wait until data is read by +* userspace. But this avoid usage of extra memory. +* +* disabled: This will disable coredump. Recovery will proceed without +* collecting any dump. +*/ +static ssize_t rproc_coredump_write (struct file *filp, +const char __user *user_buf,size_t count, +loff_t *ppos) +{ +struct rproc *rproc = filp->private_data; +int ret, err =0 ; +char buf[20 ]; + +if (count >sizeof (buf)) +return -EINVAL ; + + ret =copy_from_user (buf, user_buf, count); +if (ret) +return -EFAULT ; + +/* remove end of line */ +if (buf[count -1 ] =='\n' ) + buf[count -1 ] ='\0' ; + +if (rproc->state ==RPROC_CRASHED ) { +dev_err (&rproc->dev,"can't change coredump configuration\n" ); + err = -EBUSY ; + goto out; + } + +if (!strncmp (buf,"disable" , count)) + rproc->dump_conf =COREDUMP_DISABLED ; +else if (!strncmp (buf,"inline" , count)) + rproc->dump_conf =COREDUMP_INLINE ; +else if (!strncmp (buf,"default" , count)) + rproc->dump_conf =COREDUMP_DEFAULT ; +else { +dev_err (&rproc->dev,"Invalid coredump configuration\n" ); + err = -EINVAL ; + } +out: +return err ? err : count; +} + +static const struct file_operations rproc_coredump_fops = { + .read = rproc_coredump_read, + .write = rproc_coredump_write, + .open = simple_open, + .llseek = generic_file_llseek, +}; + +/* * Some remote processors may support dumping trace logs into a shared * memory buffer. We expose this trace buffer using debugfs, so users * can easily tell what's going on remotely.
drivers/remoteproc/remoteproc_debugfs.c void rproc_create_debug_dir(struct rproc *rproc) · line 425
Quoted 5 lines
drivers/remoteproc/remoteproc_debugfs.c +2
-0@@ -337,6 +421,8 @@ void rproc_create_debug_dir(struct rproc *rproc) rproc, &rproc_rsc_table_fops);debugfs_create_file ("carveout_memories" ,0400 , rproc->dbg_dir, rproc, &rproc_carveouts_fops); +debugfs_create_file ("coredump" ,0600 , rproc->dbg_dir, + rproc, &rproc_coredump_fops);
Quoted 6 lines
drivers/remoteproc/remoteproc_debugfs.c +0
-0}void __init rproc_init_debugfs (void )Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project