1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Coredump functionality for Remoteproc framework.
4 *
5 * Copyright (c) 2020, The Linux Foundation. All rights reserved.
6 */
7
8 #include <linux/completion.h>
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 */
rproc_coredump_cleanup(struct rproc * rproc)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 EXPORT_SYMBOL_GPL(rproc_coredump_cleanup);
36
37 /**
38 * rproc_coredump_add_segment() - add segment of device memory to coredump
39 * @rproc: handle of a remote processor
40 * @da: device address
41 * @size: size of segment
42 *
43 * Add device memory to the list of segments to be included in a coredump for
44 * the remoteproc.
45 *
46 * Return: 0 on success, negative errno on error.
47 */
rproc_coredump_add_segment(struct rproc * rproc,dma_addr_t da,size_t size)48 int rproc_coredump_add_segment(struct rproc *rproc, dma_addr_t da, size_t size)
49 {
50 struct rproc_dump_segment *segment;
51
52 segment = kzalloc(sizeof(*segment), GFP_KERNEL);
53 if (!segment)
54 return -ENOMEM;
55
56 segment->da = da;
57 segment->size = size;
58
59 list_add_tail(&segment->node, &rproc->dump_segments);
60
61 return 0;
62 }
63 EXPORT_SYMBOL(rproc_coredump_add_segment);
64
65 /**
66 * rproc_coredump_add_custom_segment() - add custom coredump segment
67 * @rproc: handle of a remote processor
68 * @da: device address
69 * @size: size of segment
70 * @dumpfn: custom dump function called for each segment during coredump
71 * @priv: private data
72 *
73 * Add device memory to the list of segments to be included in the coredump
74 * and associate the segment with the given custom dump function and private
75 * data.
76 *
77 * Return: 0 on success, negative errno on error.
78 */
rproc_coredump_add_custom_segment(struct rproc * rproc,dma_addr_t da,size_t size,void (* dumpfn)(struct rproc * rproc,struct rproc_dump_segment * segment,void * dest,size_t offset,size_t size),void * priv)79 int rproc_coredump_add_custom_segment(struct rproc *rproc,
80 dma_addr_t da, size_t size,
81 void (*dumpfn)(struct rproc *rproc,
82 struct rproc_dump_segment *segment,
83 void *dest, size_t offset,
84 size_t size),
85 void *priv)
86 {
87 struct rproc_dump_segment *segment;
88
89 segment = kzalloc(sizeof(*segment), GFP_KERNEL);
90 if (!segment)
91 return -ENOMEM;
92
93 segment->da = da;
94 segment->size = size;
95 segment->priv = priv;
96 segment->dump = dumpfn;
97
98 list_add_tail(&segment->node, &rproc->dump_segments);
99
100 return 0;
101 }
102 EXPORT_SYMBOL(rproc_coredump_add_custom_segment);
103
104 /**
105 * rproc_coredump_set_elf_info() - set coredump elf information
106 * @rproc: handle of a remote processor
107 * @class: elf class for coredump elf file
108 * @machine: elf machine for coredump elf file
109 *
110 * Set elf information which will be used for coredump elf file.
111 *
112 * Return: 0 on success, negative errno on error.
113 */
rproc_coredump_set_elf_info(struct rproc * rproc,u8 class,u16 machine)114 int rproc_coredump_set_elf_info(struct rproc *rproc, u8 class, u16 machine)
115 {
116 if (class != ELFCLASS64 && class != ELFCLASS32)
117 return -EINVAL;
118
119 rproc->elf_class = class;
120 rproc->elf_machine = machine;
121
122 return 0;
123 }
124 EXPORT_SYMBOL(rproc_coredump_set_elf_info);
125
rproc_coredump_free(void * data)126 static void rproc_coredump_free(void *data)
127 {
128 struct rproc_coredump_state *dump_state = data;
129
130 vfree(dump_state->header);
131 complete(&dump_state->dump_done);
132 }
133
rproc_coredump_find_segment(loff_t user_offset,struct list_head * segments,size_t * data_left)134 static void *rproc_coredump_find_segment(loff_t user_offset,
135 struct list_head *segments,
136 size_t *data_left)
137 {
138 struct rproc_dump_segment *segment;
139
140 list_for_each_entry(segment, segments, node) {
141 if (user_offset < segment->size) {
142 *data_left = segment->size - user_offset;
143 return segment;
144 }
145 user_offset -= segment->size;
146 }
147
148 *data_left = 0;
149 return NULL;
150 }
151
rproc_copy_segment(struct rproc * rproc,void * dest,struct rproc_dump_segment * segment,size_t offset,size_t size)152 static void rproc_copy_segment(struct rproc *rproc, void *dest,
153 struct rproc_dump_segment *segment,
154 size_t offset, size_t size)
155 {
156 bool is_iomem = false;
157 void *ptr;
158
159 if (segment->dump) {
160 segment->dump(rproc, segment, dest, offset, size);
161 } else {
162 ptr = rproc_da_to_va(rproc, segment->da + offset, size, &is_iomem);
163 if (!ptr) {
164 dev_err(&rproc->dev,
165 "invalid copy request for segment %pad with offset %zu and size %zu)\n",
166 &segment->da, offset, size);
167 memset(dest, 0xff, size);
168 } else {
169 if (is_iomem)
170 memcpy_fromio(dest, (void const __iomem *)ptr, size);
171 else
172 memcpy(dest, ptr, size);
173 }
174 }
175 }
176
rproc_coredump_read(char * buffer,loff_t offset,size_t count,void * data,size_t header_sz)177 static ssize_t rproc_coredump_read(char *buffer, loff_t offset, size_t count,
178 void *data, size_t header_sz)
179 {
180 size_t seg_data, bytes_left = count;
181 ssize_t copy_sz;
182 struct rproc_dump_segment *seg;
183 struct rproc_coredump_state *dump_state = data;
184 struct rproc *rproc = dump_state->rproc;
185 void *elfcore = dump_state->header;
186
187 /* Copy the vmalloc'ed header first. */
188 if (offset < header_sz) {
189 copy_sz = memory_read_from_buffer(buffer, count, &offset,
190 elfcore, header_sz);
191
192 return copy_sz;
193 }
194
195 /*
196 * Find out the segment memory chunk to be copied based on offset.
197 * Keep copying data until count bytes are read.
198 */
199 while (bytes_left) {
200 seg = rproc_coredump_find_segment(offset - header_sz,
201 &rproc->dump_segments,
202 &seg_data);
203 /* EOF check */
204 if (!seg) {
205 dev_info(&rproc->dev, "Ramdump done, %lld bytes read",
206 offset);
207 break;
208 }
209
210 copy_sz = min_t(size_t, bytes_left, seg_data);
211
212 rproc_copy_segment(rproc, buffer, seg, seg->size - seg_data,
213 copy_sz);
214
215 offset += copy_sz;
216 buffer += copy_sz;
217 bytes_left -= copy_sz;
218 }
219
220 return count - bytes_left;
221 }
222
223 /**
224 * rproc_coredump() - perform coredump
225 * @rproc: rproc handle
226 *
227 * This function will generate an ELF header for the registered segments
228 * and create a devcoredump device associated with rproc. Based on the
229 * coredump configuration this function will directly copy the segments
230 * from device memory to userspace or copy segments from device memory to
231 * a separate buffer, which can then be read by userspace.
232 * The first approach avoids using extra vmalloc memory. But it will stall
233 * recovery flow until dump is read by userspace.
234 */
rproc_coredump(struct rproc * rproc)235 void rproc_coredump(struct rproc *rproc)
236 {
237 struct rproc_dump_segment *segment;
238 void *phdr;
239 void *ehdr;
240 size_t data_size;
241 size_t offset;
242 void *data;
243 u8 class = rproc->elf_class;
244 int phnum = 0;
245 struct rproc_coredump_state dump_state;
246 enum rproc_dump_mechanism dump_conf = rproc->dump_conf;
247
248 if (list_empty(&rproc->dump_segments) ||
249 dump_conf == RPROC_COREDUMP_DISABLED)
250 return;
251
252 if (class == ELFCLASSNONE) {
253 dev_err(&rproc->dev, "Elf class is not set\n");
254 return;
255 }
256
257 data_size = elf_size_of_hdr(class);
258 list_for_each_entry(segment, &rproc->dump_segments, node) {
259 /*
260 * For default configuration buffer includes headers & segments.
261 * For inline dump buffer just includes headers as segments are
262 * directly read from device memory.
263 */
264 data_size += elf_size_of_phdr(class);
265 if (dump_conf == RPROC_COREDUMP_ENABLED)
266 data_size += segment->size;
267
268 phnum++;
269 }
270
271 data = vmalloc(data_size);
272 if (!data)
273 return;
274
275 ehdr = data;
276
277 memset(ehdr, 0, elf_size_of_hdr(class));
278 /* e_ident field is common for both elf32 and elf64 */
279 elf_hdr_init_ident(ehdr, class);
280
281 elf_hdr_set_e_type(class, ehdr, ET_CORE);
282 elf_hdr_set_e_machine(class, ehdr, rproc->elf_machine);
283 elf_hdr_set_e_version(class, ehdr, EV_CURRENT);
284 elf_hdr_set_e_entry(class, ehdr, rproc->bootaddr);
285 elf_hdr_set_e_phoff(class, ehdr, elf_size_of_hdr(class));
286 elf_hdr_set_e_ehsize(class, ehdr, elf_size_of_hdr(class));
287 elf_hdr_set_e_phentsize(class, ehdr, elf_size_of_phdr(class));
288 elf_hdr_set_e_phnum(class, ehdr, phnum);
289
290 phdr = data + elf_hdr_get_e_phoff(class, ehdr);
291 offset = elf_hdr_get_e_phoff(class, ehdr);
292 offset += elf_size_of_phdr(class) * elf_hdr_get_e_phnum(class, ehdr);
293
294 list_for_each_entry(segment, &rproc->dump_segments, node) {
295 memset(phdr, 0, elf_size_of_phdr(class));
296 elf_phdr_set_p_type(class, phdr, PT_LOAD);
297 elf_phdr_set_p_offset(class, phdr, offset);
298 elf_phdr_set_p_vaddr(class, phdr, segment->da);
299 elf_phdr_set_p_paddr(class, phdr, segment->da);
300 elf_phdr_set_p_filesz(class, phdr, segment->size);
301 elf_phdr_set_p_memsz(class, phdr, segment->size);
302 elf_phdr_set_p_flags(class, phdr, PF_R | PF_W | PF_X);
303 elf_phdr_set_p_align(class, phdr, 0);
304
305 if (dump_conf == RPROC_COREDUMP_ENABLED)
306 rproc_copy_segment(rproc, data + offset, segment, 0,
307 segment->size);
308
309 offset += elf_phdr_get_p_filesz(class, phdr);
310 phdr += elf_size_of_phdr(class);
311 }
312 if (dump_conf == RPROC_COREDUMP_ENABLED) {
313 dev_coredumpv(&rproc->dev, data, data_size, GFP_KERNEL);
314 return;
315 }
316
317 /* Initialize the dump state struct to be used by rproc_coredump_read */
318 dump_state.rproc = rproc;
319 dump_state.header = data;
320 init_completion(&dump_state.dump_done);
321
322 dev_coredumpm(&rproc->dev, NULL, &dump_state, data_size, GFP_KERNEL,
323 rproc_coredump_read, rproc_coredump_free);
324
325 /*
326 * Wait until the dump is read and free is called. Data is freed
327 * by devcoredump framework automatically after 5 minutes.
328 */
329 wait_for_completion(&dump_state.dump_done);
330 }
331 EXPORT_SYMBOL_GPL(rproc_coredump);
332
333 /**
334 * rproc_coredump_using_sections() - perform coredump using section headers
335 * @rproc: rproc handle
336 *
337 * This function will generate an ELF header for the registered sections of
338 * segments and create a devcoredump device associated with rproc. Based on
339 * the coredump configuration this function will directly copy the segments
340 * from device memory to userspace or copy segments from device memory to
341 * a separate buffer, which can then be read by userspace.
342 * The first approach avoids using extra vmalloc memory. But it will stall
343 * recovery flow until dump is read by userspace.
344 */
rproc_coredump_using_sections(struct rproc * rproc)345 void rproc_coredump_using_sections(struct rproc *rproc)
346 {
347 struct rproc_dump_segment *segment;
348 void *shdr;
349 void *ehdr;
350 size_t data_size;
351 size_t strtbl_size = 0;
352 size_t strtbl_index = 1;
353 size_t offset;
354 void *data;
355 u8 class = rproc->elf_class;
356 int shnum;
357 struct rproc_coredump_state dump_state;
358 unsigned int dump_conf = rproc->dump_conf;
359 char *str_tbl = "STR_TBL";
360
361 if (list_empty(&rproc->dump_segments) ||
362 dump_conf == RPROC_COREDUMP_DISABLED)
363 return;
364
365 if (class == ELFCLASSNONE) {
366 dev_err(&rproc->dev, "Elf class is not set\n");
367 return;
368 }
369
370 /*
371 * We allocate two extra section headers. The first one is null.
372 * Second section header is for the string table. Also space is
373 * allocated for string table.
374 */
375 data_size = elf_size_of_hdr(class) + 2 * elf_size_of_shdr(class);
376 shnum = 2;
377
378 /* the extra byte is for the null character at index 0 */
379 strtbl_size += strlen(str_tbl) + 2;
380
381 list_for_each_entry(segment, &rproc->dump_segments, node) {
382 data_size += elf_size_of_shdr(class);
383 strtbl_size += strlen(segment->priv) + 1;
384 if (dump_conf == RPROC_COREDUMP_ENABLED)
385 data_size += segment->size;
386 shnum++;
387 }
388
389 data_size += strtbl_size;
390
391 data = vmalloc(data_size);
392 if (!data)
393 return;
394
395 ehdr = data;
396 memset(ehdr, 0, elf_size_of_hdr(class));
397 /* e_ident field is common for both elf32 and elf64 */
398 elf_hdr_init_ident(ehdr, class);
399
400 elf_hdr_set_e_type(class, ehdr, ET_CORE);
401 elf_hdr_set_e_machine(class, ehdr, rproc->elf_machine);
402 elf_hdr_set_e_version(class, ehdr, EV_CURRENT);
403 elf_hdr_set_e_entry(class, ehdr, rproc->bootaddr);
404 elf_hdr_set_e_shoff(class, ehdr, elf_size_of_hdr(class));
405 elf_hdr_set_e_ehsize(class, ehdr, elf_size_of_hdr(class));
406 elf_hdr_set_e_shentsize(class, ehdr, elf_size_of_shdr(class));
407 elf_hdr_set_e_shnum(class, ehdr, shnum);
408 elf_hdr_set_e_shstrndx(class, ehdr, 1);
409
410 /*
411 * The zeroth index of the section header is reserved and is rarely used.
412 * Set the section header as null (SHN_UNDEF) and move to the next one.
413 */
414 shdr = data + elf_hdr_get_e_shoff(class, ehdr);
415 memset(shdr, 0, elf_size_of_shdr(class));
416 shdr += elf_size_of_shdr(class);
417
418 /* Initialize the string table. */
419 offset = elf_hdr_get_e_shoff(class, ehdr) +
420 elf_size_of_shdr(class) * elf_hdr_get_e_shnum(class, ehdr);
421 memset(data + offset, 0, strtbl_size);
422
423 /* Fill in the string table section header. */
424 memset(shdr, 0, elf_size_of_shdr(class));
425 elf_shdr_set_sh_type(class, shdr, SHT_STRTAB);
426 elf_shdr_set_sh_offset(class, shdr, offset);
427 elf_shdr_set_sh_size(class, shdr, strtbl_size);
428 elf_shdr_set_sh_entsize(class, shdr, 0);
429 elf_shdr_set_sh_flags(class, shdr, 0);
430 elf_shdr_set_sh_name(class, shdr, elf_strtbl_add(str_tbl, ehdr, class, &strtbl_index));
431 offset += elf_shdr_get_sh_size(class, shdr);
432 shdr += elf_size_of_shdr(class);
433
434 list_for_each_entry(segment, &rproc->dump_segments, node) {
435 memset(shdr, 0, elf_size_of_shdr(class));
436 elf_shdr_set_sh_type(class, shdr, SHT_PROGBITS);
437 elf_shdr_set_sh_offset(class, shdr, offset);
438 elf_shdr_set_sh_addr(class, shdr, segment->da);
439 elf_shdr_set_sh_size(class, shdr, segment->size);
440 elf_shdr_set_sh_entsize(class, shdr, 0);
441 elf_shdr_set_sh_flags(class, shdr, SHF_WRITE);
442 elf_shdr_set_sh_name(class, shdr,
443 elf_strtbl_add(segment->priv, ehdr, class, &strtbl_index));
444
445 /* No need to copy segments for inline dumps */
446 if (dump_conf == RPROC_COREDUMP_ENABLED)
447 rproc_copy_segment(rproc, data + offset, segment, 0,
448 segment->size);
449 offset += elf_shdr_get_sh_size(class, shdr);
450 shdr += elf_size_of_shdr(class);
451 }
452
453 if (dump_conf == RPROC_COREDUMP_ENABLED) {
454 dev_coredumpv(&rproc->dev, data, data_size, GFP_KERNEL);
455 return;
456 }
457
458 /* Initialize the dump state struct to be used by rproc_coredump_read */
459 dump_state.rproc = rproc;
460 dump_state.header = data;
461 init_completion(&dump_state.dump_done);
462
463 dev_coredumpm(&rproc->dev, NULL, &dump_state, data_size, GFP_KERNEL,
464 rproc_coredump_read, rproc_coredump_free);
465
466 /* Wait until the dump is read and free is called. Data is freed
467 * by devcoredump framework automatically after 5 minutes.
468 */
469 wait_for_completion(&dump_state.dump_done);
470 }
471 EXPORT_SYMBOL(rproc_coredump_using_sections);
472