| Message ID | 1592961854-634-3-git-send-email-rishabhb@codeaurora.org (mailing list archive) |
|---|---|
| State | Superseded |
| Headers | show |
| Series | Extend coredump functionality | expand |
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
Reported-by: kernel test robot <lkp@intel.com>
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@lists.01.org
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
Reported-by: kernel test robot <lkp@intel.com>
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@lists.01.org
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
Reported-by: kernel test robot <lkp@intel.com>
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@lists.01.org
diff --git a/drivers/remoteproc/qcom_q6v5_mss.c b/drivers/remoteproc/qcom_q6v5_mss.c index 903b2bb..d4ff9b8 100644 --- a/drivers/remoteproc/qcom_q6v5_mss.c +++ b/drivers/remoteproc/qcom_q6v5_mss.c @@ -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; diff --git a/drivers/remoteproc/remoteproc_coredump.c b/drivers/remoteproc/remoteproc_coredump.c index ded0244..e643a66 100644 --- a/drivers/remoteproc/remoteproc_coredump.c +++ b/drivers/remoteproc/remoteproc_coredump.c @@ -5,6 +5,7 @@ * 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> @@ -12,6 +13,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 @@ -72,7 +79,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) { struct rproc_dump_segment *segment; @@ -114,12 +122,112 @@ 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 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 (%zu, %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; + size_t copy_sz, bytes_left = count; + 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); + 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) { + 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. + * 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) { @@ -129,11 +237,13 @@ void rproc_coredump(struct rproc *rproc) size_t data_size; size_t offset; void *data; - 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 == RPROC_COREDUMP_DISABLED) return; if (class == ELFCLASSNONE) { @@ -143,7 +253,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 == RPROC_COREDUMP_DEFAULT) + data_size += segment->size; phnum++; } @@ -182,23 +299,30 @@ 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); - 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); - } - } + if (dump_conf == RPROC_COREDUMP_DEFAULT) + rproc_copy_segment(rproc, data + offset, segment, 0, + 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); + if (dump_conf == RPROC_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); } diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h index e7b7bab..43e45a3 100644 --- a/include/linux/remoteproc.h +++ b/include/linux/remoteproc.h @@ -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);
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 <rishabhb@codeaurora.org> --- 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(-)