Skip to contentSkip to conversation

Extend coredump functionality

PATCH Superseded Rishabh Bhatnagar 2 participants 7 messages Jun 24, 2020 – Jun 25, 2020

Subsystems (2)

v5 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#0 lore raw

v5 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 until all data is read by userspace.

Changelog:

v5 -> v4:
- Rebase on top of linux-next

v4 -> v3:
- Write a helper function to copy segment memory for every dump format
- Change segment dump fn to add offset and size adn covert mss driver

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/qcom_q6v5_mss.c       |   9 +-
 drivers/remoteproc/remoteproc_core.c     | 191 ------------------
 drivers/remoteproc/remoteproc_coredump.c | 328 +++++++++++++++++++++++++++++++
 drivers/remoteproc/remoteproc_debugfs.c  |  86 ++++++++
 drivers/remoteproc/remoteproc_internal.h |   4 +
 include/linux/remoteproc.h               |  21 +-
 7 files changed, 443 insertions(+), 197 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
#1 lore raw

PATCH v5 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
index e8b886e..8702a4e 100644
@@ -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
index 4ba7cb5..97d441b 100644
@@ -47,6 +47,10 @@ extern struct class rproc_class;
 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
#2 lore raw

PATCH v5 2/3 remoteproc: Add inline coredump functionality

In reply to 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.

---
 drivers/remoteproc/qcom_q6v5_mss.c       |   9 +-
 drivers/remoteproc/remoteproc_coredump.c | 162 +++++++++++++++++++++++++++----
 include/linux/remoteproc.h               |  21 +++-
 3 files changed, 167 insertions(+), 25 deletions(-)
drivers/remoteproc/qcom_q6v5_mss.c +5 -4
index 903b2bb..d4ff9b8 100644
@@ -1200,12 +1200,13 @@ static int q6v5_mpss_load(struct q6v5 *qproc)
 
 static void qcom_q6v5_dump_segment(struct rproc *rproc,
 				   struct rproc_dump_segment *segment,
-				   void *dest)
+				   void *dest, size_t cp_offset, size_t size)
 {
 	int ret = 0;
 	struct q6v5 *qproc = rproc->priv;
 	unsigned long mask = BIT((unsigned long)segment->priv);
 	int offset = segment->da - qproc->mpss_reloc;
+	size_t cp_size = size ? size : segment->size;
 	void *ptr = NULL;
 
 	/* Unlock mba before copying segments */
@@ -1221,13 +1222,13 @@ static void qcom_q6v5_dump_segment(struct rproc *rproc,
 	}
 
 	if (!ret)
-		ptr = ioremap_wc(qproc->mpss_phys + offset, segment->size);
+		ptr = ioremap_wc(qproc->mpss_phys + offset + cp_offset, cp_size);
 
 	if (ptr) {
-		memcpy(dest, ptr, segment->size);
+		memcpy(dest, ptr, cp_size);
 		iounmap(ptr);
 	} else {
-		memset(dest, 0xff, segment->size);
+		memset(dest, 0xff, cp_size);
 	}
 
 	qproc->dump_segment_mask |= mask;
drivers/remoteproc/remoteproc_coredump.c +143 -19

215 lines not on this page · raw message

include/linux/remoteproc.h +19 -2
index e7b7bab..43e45a3 100644
@@ -435,6 +435,20 @@ enum rproc_crash_type {
 };
 
 /**
+ * enum rproc_dump_mechanism - Coredump options for core
+ * @RPROC_COREDUMP_DEFAULT:	Copy dump to separate buffer and carry on with
+				recovery
+ * @RPROC_COREDUMP_INLINE:	Read segments directly from device memory. Stall
+				recovery until all segments are read
+ * @RPROC_COREDUMP_DISABLED:	Don't perform any dump
+ */
+enum rproc_dump_mechanism {
+	RPROC_COREDUMP_DEFAULT,
+	RPROC_COREDUMP_INLINE,
+	RPROC_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
@@ -451,7 +465,7 @@ struct rproc_dump_segment {
 
 	void *priv;
 	void (*dump)(struct rproc *rproc, struct rproc_dump_segment *segment,
-		     void *dest);
+		     void *dest, size_t offset, size_t size);
 	loff_t offset;
 };
 
@@ -466,6 +480,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 +514,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;
@@ -630,7 +646,8 @@ 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 *dest, size_t offset,
+						     size_t size),
 				      void *priv);
 int rproc_coredump_set_elf_info(struct rproc *rproc, u8 class, u16 machine);
 
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
a Linux Foundation Collaborative Project
#3 lore raw

Re: [PATCH v5 2/3] remoteproc: Add inline coredump functionality

Thank you for the patch! Perhaps something to improve:

Hi Rishabh,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on linux/master]
[also build test WARNING on linus/master v5.8-rc2 next-20200623] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Rishabh-Bhatnagar/Extend-coredump-functionality/20200624-092759
base:   https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git 5e857ce6eae7ca21b2055cca4885545e29228fe2
config: arc-allyesconfig (attached as .config)
compiler: arc-elf-gcc (GCC) 9.3.0

reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=arc

If you fix the issue, kindly add following tag as appropriate

All warnings (new ones prefixed by >>):

In file included from include/linux/device.h:15,
from include/linux/devcoredump.h:8,
from drivers/remoteproc/remoteproc_coredump.c:9:
drivers/remoteproc/remoteproc_coredump.c: In function 'rproc_copy_segment':

>> drivers/remoteproc/remoteproc_coredump.c:163:5: warning: format '%zu' expects argument of type 'size_t', but argument 3 has type 'dma_addr_t' {aka 'long long unsigned int'} [-Wformat=]
     163 |     "invalid copy request (%zu, %zu)\n",
         |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   include/linux/dev_printk.h:19:22: note: in definition of macro 'dev_fmt'
      19 | #define dev_fmt(fmt) fmt
         |                      ^~~
>> drivers/remoteproc/remoteproc_coredump.c:162:4: note: in expansion of macro 'dev_err'
     162 |    dev_err(&rproc->dev,
         |    ^~~~~~~
   drivers/remoteproc/remoteproc_coredump.c:163:30: note: format string is defined here
     163 |     "invalid copy request (%zu, %zu)\n",
         |                            ~~^
         |                              |
         |                              unsigned int
         |                            %llu
   drivers/remoteproc/remoteproc_coredump.c: In function 'rproc_coredump_read':
>> drivers/remoteproc/remoteproc_coredump.c:186:15: warning: comparison of unsigned expression < 0 is always false [-Wtype-limits]
     186 |   if (copy_sz < 0)
         |               ^

vim +163 drivers/remoteproc/remoteproc_coredump.c

   > 9	#include <linux/devcoredump.h>
    10	#include <linux/device.h>
    11	#include <linux/kernel.h>
    12	#include <linux/remoteproc.h>
    13	#include "remoteproc_internal.h"
    14	#include "remoteproc_elf_helpers.h"
    15	
    16	struct rproc_coredump_state {
    17		struct rproc *rproc;
    18		void *header;
    19		struct completion dump_done;
    20	};
    21	
    22	/**
    23	 * rproc_coredump_cleanup() - clean up dump_segments list
    24	 * @rproc: the remote processor handle
    25	 */
    26	void rproc_coredump_cleanup(struct rproc *rproc)
    27	{
    28		struct rproc_dump_segment *entry, *tmp;
    29	
    30		list_for_each_entry_safe(entry, tmp, &rproc->dump_segments, node) {
    31			list_del(&entry->node);
    32			kfree(entry);
    33		}
    34	}
    35	
    36	/**
    37	 * rproc_coredump_add_segment() - add segment of device memory to coredump
    38	 * @rproc:	handle of a remote processor
    39	 * @da:		device address
    40	 * @size:	size of segment
    41	 *
    42	 * Add device memory to the list of segments to be included in a coredump for
    43	 * the remoteproc.
    44	 *
    45	 * Return: 0 on success, negative errno on error.
    46	 */
    47	int rproc_coredump_add_segment(struct rproc *rproc, dma_addr_t da, size_t size)
    48	{
    49		struct rproc_dump_segment *segment;
    50	
    51		segment = kzalloc(sizeof(*segment), GFP_KERNEL);
    52		if (!segment)
    53			return -ENOMEM;
    54	
    55		segment->da = da;
    56		segment->size = size;
    57	
    58		list_add_tail(&segment->node, &rproc->dump_segments);
    59	
    60		return 0;
    61	}
    62	EXPORT_SYMBOL(rproc_coredump_add_segment);
    63	
    64	/**
    65	 * rproc_coredump_add_custom_segment() - add custom coredump segment
    66	 * @rproc:	handle of a remote processor
    67	 * @da:		device address
    68	 * @size:	size of segment
    69	 * @dumpfn:	custom dump function called for each segment during coredump
    70	 * @priv:	private data
    71	 *
    72	 * Add device memory to the list of segments to be included in the coredump
    73	 * and associate the segment with the given custom dump function and private
    74	 * data.
    75	 *
    76	 * Return: 0 on success, negative errno on error.
    77	 */
    78	int rproc_coredump_add_custom_segment(struct rproc *rproc,
    79					      dma_addr_t da, size_t size,
    80					      void (*dumpfn)(struct rproc *rproc,
    81							     struct rproc_dump_segment *segment,
    82							     void *dest, size_t offset,
    83							     size_t size),
    84					      void *priv)
    85	{
    86		struct rproc_dump_segment *segment;
    87	
    88		segment = kzalloc(sizeof(*segment), GFP_KERNEL);
    89		if (!segment)
    90			return -ENOMEM;
    91	
    92		segment->da = da;
    93		segment->size = size;
    94		segment->priv = priv;
    95		segment->dump = dumpfn;
    96	
    97		list_add_tail(&segment->node, &rproc->dump_segments);
    98	
    99		return 0;
   100	}
   101	EXPORT_SYMBOL(rproc_coredump_add_custom_segment);
   102	
   103	/**
   104	 * rproc_coredump_set_elf_info() - set coredump elf information
   105	 * @rproc:	handle of a remote processor
   106	 * @class:	elf class for coredump elf file
   107	 * @machine:	elf machine for coredump elf file
   108	 *
   109	 * Set elf information which will be used for coredump elf file.
   110	 *
   111	 * Return: 0 on success, negative errno on error.
   112	 */
   113	int rproc_coredump_set_elf_info(struct rproc *rproc, u8 class, u16 machine)
   114	{
   115		if (class != ELFCLASS64 && class != ELFCLASS32)
   116			return -EINVAL;
   117	
   118		rproc->elf_class = class;
   119		rproc->elf_machine = machine;
   120	
   121		return 0;
   122	}
   123	EXPORT_SYMBOL(rproc_coredump_set_elf_info);
   124	
   125	static void rproc_coredump_free(void *data)
   126	{
   127		struct rproc_coredump_state *dump_state = data;
   128	
   129		complete(&dump_state->dump_done);
   130		vfree(dump_state->header);
   131	}
   132	
   133	static void *rproc_coredump_find_segment(loff_t user_offset,
   134						 struct list_head *segments,
   135						 size_t *data_left)
   136	{
   137		struct rproc_dump_segment *segment;
   138	
   139		list_for_each_entry(segment, segments, node) {
   140			if (user_offset < segment->size) {
   141				*data_left = segment->size - user_offset;
   142				return segment;
   143			}
   144			user_offset -= segment->size;
   145		}
   146	
   147		*data_left = 0;
   148		return NULL;
   149	}
   150	
   151	static void rproc_copy_segment(struct rproc *rproc, void *dest,
   152				       struct rproc_dump_segment *segment,
   153				       size_t offset, size_t size)
   154	{
   155		void *ptr;
   156	
   157		if (segment->dump) {
   158			segment->dump(rproc, segment, dest, offset, size);
   159		} else {
   160			ptr = rproc_da_to_va(rproc, segment->da + offset, size);
   161			if (!ptr) {
 > 162				dev_err(&rproc->dev,
 > 163					"invalid copy request (%zu, %zu)\n",
   164					segment->da + offset, size);
   165				memset(dest, 0xff, size);
   166			} else {
   167				memcpy(dest, ptr, size);
   168			}
   169		}
   170	}
   171	
   172	static ssize_t rproc_coredump_read(char *buffer, loff_t offset, size_t count,
   173					   void *data, size_t header_sz)
   174	{
   175		size_t seg_data;
   176		size_t copy_sz, bytes_left = count;
   177		struct rproc_dump_segment *seg;
   178		struct rproc_coredump_state *dump_state = data;
   179		struct rproc *rproc = dump_state->rproc;
   180		void *elfcore = dump_state->header;
   181	
   182		/* Copy the vmalloc'ed header first. */
   183		if (offset < header_sz) {
   184			copy_sz = memory_read_from_buffer(buffer, count, &offset,
   185							  elfcore, header_sz);
 > 186			if (copy_sz < 0)

187 return -EINVAL;
188
189 return copy_sz;
190 }
191
192 /*
193 * Find out the segment memory chunk to be copied based on offset.
194 * Keep copying data until count bytes are read.
195 */
196 while (bytes_left) {
197 seg = rproc_coredump_find_segment(offset - header_sz,
198 &rproc->dump_segments,
199 &seg_data);
200 /* EOF check */
201 if (!seg) {
202 dev_info(&rproc->dev, "Ramdump done, %lld bytes read",
203 offset);
204 break;
205 }
206
207 copy_sz = min_t(size_t, bytes_left, seg_data);
208
209 rproc_copy_segment(rproc, buffer, seg, seg->size - seg_data,
210 copy_sz);
211
212 offset += copy_sz;
213 buffer += copy_sz;
214 bytes_left -= copy_sz;
215 }
216
217 return count - bytes_left;
218 }
219

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

#4 lore raw

Re: [PATCH v5 2/3] remoteproc: Add inline coredump functionality

In reply to Rishabh Bhatnagar
Thank you for the patch! Perhaps something to improve:

Hi Rishabh,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on linux/master]
[also build test WARNING on linus/master v5.8-rc2 next-20200624] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Rishabh-Bhatnagar/Extend-coredump-functionality/20200624-092759
base:   https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git 5e857ce6eae7ca21b2055cca4885545e29228fe2
config: i386-randconfig-a011-20200624 (attached as .config)
compiler: gcc-9 (Debian 9.3.0-13) 9.3.0
reproduce (this is a W=1 build):
        # save the attached .config to linux build tree
        make W=1 ARCH=i386 

If you fix the issue, kindly add following tag as appropriate

All warnings (new ones prefixed by >>):

In file included from include/linux/export.h:43,
from include/linux/linkage.h:7,
from include/linux/kernel.h:8,
from include/linux/list.h:9,
from include/linux/swait.h:5,
from include/linux/completion.h:12,
from drivers/remoteproc/remoteproc_coredump.c:8:
drivers/remoteproc/remoteproc_coredump.c: In function 'rproc_coredump_read':
drivers/remoteproc/remoteproc_coredump.c:186:15: warning: comparison of unsigned expression < 0 is always false [-Wtype-limits]

     186 |   if (copy_sz < 0)
         |               ^
   include/linux/compiler.h:58:52: note: in definition of macro '__trace_if_var'
      58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond) : __trace_if_value(cond))
         |                                                    ^~~~
>> drivers/remoteproc/remoteproc_coredump.c:186:3: note: in expansion of macro 'if'
     186 |   if (copy_sz < 0)
         |   ^~
   drivers/remoteproc/remoteproc_coredump.c:186:15: warning: comparison of unsigned expression < 0 is always false [-Wtype-limits]
     186 |   if (copy_sz < 0)
         |               ^
   include/linux/compiler.h:58:61: note: in definition of macro '__trace_if_var'
      58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond) : __trace_if_value(cond))
         |                                                             ^~~~
>> drivers/remoteproc/remoteproc_coredump.c:186:3: note: in expansion of macro 'if'
     186 |   if (copy_sz < 0)
         |   ^~
   drivers/remoteproc/remoteproc_coredump.c:186:15: warning: comparison of unsigned expression < 0 is always false [-Wtype-limits]
     186 |   if (copy_sz < 0)
         |               ^
   include/linux/compiler.h:69:3: note: in definition of macro '__trace_if_value'
      69 |  (cond) ?     \
         |   ^~~~
   include/linux/compiler.h:56:28: note: in expansion of macro '__trace_if_var'
      56 | #define if(cond, ...) if ( __trace_if_var( !!(cond , ## __VA_ARGS__) ) )
         |                            ^~~~~~~~~~~~~~
>> drivers/remoteproc/remoteproc_coredump.c:186:3: note: in expansion of macro 'if'
     186 |   if (copy_sz < 0)
         |   ^~

vim +/if +186 drivers/remoteproc/remoteproc_coredump.c

171
172 static ssize_t rproc_coredump_read(char *buffer, loff_t offset, size_t count,
173 void *data, size_t header_sz)
174 {
175 size_t seg_data;
176 size_t copy_sz, bytes_left = count;
177 struct rproc_dump_segment *seg;
178 struct rproc_coredump_state *dump_state = data;
179 struct rproc *rproc = dump_state->rproc;
180 void *elfcore = dump_state->header;
181
182 /* Copy the vmalloc'ed header first. */
183 if (offset < header_sz) {
184 copy_sz = memory_read_from_buffer(buffer, count, &offset,
185 elfcore, header_sz);

 > 186			if (copy_sz < 0)

187 return -EINVAL;
188
189 return copy_sz;
190 }
191
192 /*
193 * Find out the segment memory chunk to be copied based on offset.
194 * Keep copying data until count bytes are read.
195 */
196 while (bytes_left) {
197 seg = rproc_coredump_find_segment(offset - header_sz,
198 &rproc->dump_segments,
199 &seg_data);
200 /* EOF check */
201 if (!seg) {
202 dev_info(&rproc->dev, "Ramdump done, %lld bytes read",
203 offset);
204 break;
205 }
206
207 copy_sz = min_t(size_t, bytes_left, seg_data);
208
209 rproc_copy_segment(rproc, buffer, seg, seg->size - seg_data,
210 copy_sz);
211
212 offset += copy_sz;
213 buffer += copy_sz;
214 bytes_left -= copy_sz;
215 }
216
217 return count - bytes_left;
218 }
219

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

#5 lore raw

Re: [PATCH v5 2/3] remoteproc: Add inline coredump functionality

In reply to Rishabh Bhatnagar
Thank you for the patch! Perhaps something to improve:

Hi Rishabh,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on linux/master]
[also build test WARNING on linus/master v5.8-rc2 next-20200625] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Rishabh-Bhatnagar/Extend-coredump-functionality/20200624-092759
base:   https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git 5e857ce6eae7ca21b2055cca4885545e29228fe2
config: h8300-randconfig-m031-20200624 (attached as .config)
compiler: h8300-linux-gcc (GCC) 9.3.0

If you fix the issue, kindly add following tag as appropriate

smatch warnings:
drivers/remoteproc/remoteproc_coredump.c:186 rproc_coredump_read() warn: unsigned 'copy_sz' is never less than zero.

vim +/copy_sz +186 drivers/remoteproc/remoteproc_coredump.c

171
172 static ssize_t rproc_coredump_read(char *buffer, loff_t offset, size_t count,
173 void *data, size_t header_sz)
174 {
175 size_t seg_data;
176 size_t copy_sz, bytes_left = count;
177 struct rproc_dump_segment *seg;
178 struct rproc_coredump_state *dump_state = data;
179 struct rproc *rproc = dump_state->rproc;
180 void *elfcore = dump_state->header;
181
182 /* Copy the vmalloc'ed header first. */
183 if (offset < header_sz) {
184 copy_sz = memory_read_from_buffer(buffer, count, &offset,
185 elfcore, header_sz);

 > 186			if (copy_sz < 0)

187 return -EINVAL;
188
189 return copy_sz;
190 }
191
192 /*
193 * Find out the segment memory chunk to be copied based on offset.
194 * Keep copying data until count bytes are read.
195 */
196 while (bytes_left) {
197 seg = rproc_coredump_find_segment(offset - header_sz,
198 &rproc->dump_segments,
199 &seg_data);
200 /* EOF check */
201 if (!seg) {
202 dev_info(&rproc->dev, "Ramdump done, %lld bytes read",
203 offset);
204 break;
205 }
206
207 copy_sz = min_t(size_t, bytes_left, seg_data);
208
209 rproc_copy_segment(rproc, buffer, seg, seg->size - seg_data,
210 copy_sz);
211
212 offset += copy_sz;
213 buffer += copy_sz;
214 bytes_left -= copy_sz;
215 }
216
217 return count - bytes_left;
218 }
219

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

#6 lore raw

PATCH v5 3/3 remoteproc: Add coredump debugfs entry

In reply to 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.

---
 drivers/remoteproc/remoteproc_debugfs.c | 86 +++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
drivers/remoteproc/remoteproc_debugfs.c +86 -0
index 732770e..cca0a91 100644
@@ -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[] = {
+	[RPROC_COREDUMP_DEFAULT]	= "default",
+	[RPROC_COREDUMP_INLINE]	= "inline",
+	[RPROC_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 = RPROC_COREDUMP_DISABLED;
+	} else if (!strncmp(buf, "inline", count)) {
+		rproc->dump_conf = RPROC_COREDUMP_INLINE;
+	} else if (!strncmp(buf, "default", count)) {
+		rproc->dump_conf = RPROC_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