Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
fileio: fileio_size() can now fail
[openocd.git] / src / target / image.c
1 /***************************************************************************
2 * Copyright (C) 2007 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
10 * *
11 * Copyright (C) 2009 by Franck Hereson *
12 * franck.hereson@secad.fr *
13 * *
14 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
18 * *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program; if not, write to the *
26 * Free Software Foundation, Inc., *
27 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
28 ***************************************************************************/
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include "image.h"
34 #include "target.h"
35 #include <helper/log.h>
36
37
38 /* convert ELF header field to host endianness */
39 #define field16(elf,field)\
40 ((elf->endianness == ELFDATA2LSB)? \
41 le_to_h_u16((uint8_t*)&field):be_to_h_u16((uint8_t*)&field))
42
43 #define field32(elf,field)\
44 ((elf->endianness == ELFDATA2LSB)? \
45 le_to_h_u32((uint8_t*)&field):be_to_h_u32((uint8_t*)&field))
46
47 static int autodetect_image_type(struct image *image, const char *url)
48 {
49 int retval;
50 struct fileio fileio;
51 size_t read_bytes;
52 uint8_t buffer[9];
53
54 /* read the first 4 bytes of image */
55 if ((retval = fileio_open(&fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
56 {
57 return retval;
58 }
59 retval = fileio_read(&fileio, 9, buffer, &read_bytes);
60
61 if (retval == ERROR_OK)
62 {
63 if (read_bytes != 9)
64 {
65 retval = ERROR_FILEIO_OPERATION_FAILED;
66 }
67 }
68 fileio_close(&fileio);
69
70 if (retval != ERROR_OK)
71 return retval;
72
73 /* check header against known signatures */
74 if (strncmp((char*)buffer,ELFMAG,SELFMAG) == 0)
75 {
76 LOG_DEBUG("ELF image detected.");
77 image->type = IMAGE_ELF;
78 }
79 else if ((buffer[0]==':') /* record start byte */
80 &&(isxdigit(buffer[1]))
81 &&(isxdigit(buffer[2]))
82 &&(isxdigit(buffer[3]))
83 &&(isxdigit(buffer[4]))
84 &&(isxdigit(buffer[5]))
85 &&(isxdigit(buffer[6]))
86 &&(buffer[7]=='0') /* record type : 00 -> 05 */
87 &&(buffer[8]>='0') && (buffer[8]<'6'))
88 {
89 LOG_DEBUG("IHEX image detected.");
90 image->type = IMAGE_IHEX;
91 }
92 else if ((buffer[0] == 'S') /* record start byte */
93 &&(isxdigit(buffer[1]))
94 &&(isxdigit(buffer[2]))
95 &&(isxdigit(buffer[3]))
96 &&(buffer[1] >= '0') && (buffer[1] < '9'))
97 {
98 LOG_DEBUG("S19 image detected.");
99 image->type = IMAGE_SRECORD;
100 }
101 else
102 {
103 image->type = IMAGE_BINARY;
104 }
105
106 return ERROR_OK;
107 }
108
109 static int identify_image_type(struct image *image, const char *type_string, const char *url)
110 {
111 if (type_string)
112 {
113 if (!strcmp(type_string, "bin"))
114 {
115 image->type = IMAGE_BINARY;
116 }
117 else if (!strcmp(type_string, "ihex"))
118 {
119 image->type = IMAGE_IHEX;
120 }
121 else if (!strcmp(type_string, "elf"))
122 {
123 image->type = IMAGE_ELF;
124 }
125 else if (!strcmp(type_string, "mem"))
126 {
127 image->type = IMAGE_MEMORY;
128 }
129 else if (!strcmp(type_string, "s19"))
130 {
131 image->type = IMAGE_SRECORD;
132 }
133 else if (!strcmp(type_string, "build"))
134 {
135 image->type = IMAGE_BUILDER;
136 }
137 else
138 {
139 return ERROR_IMAGE_TYPE_UNKNOWN;
140 }
141 }
142 else
143 {
144 return autodetect_image_type(image, url);
145 }
146
147 return ERROR_OK;
148 }
149
150 static int image_ihex_buffer_complete_inner(struct image *image, char *lpszLine, struct imagesection *section)
151 {
152 struct image_ihex *ihex = image->type_private;
153 struct fileio *fileio = &ihex->fileio;
154 uint32_t full_address = 0x0;
155 uint32_t cooked_bytes;
156 int i;
157
158 /* we can't determine the number of sections that we'll have to create ahead of time,
159 * so we locally hold them until parsing is finished */
160
161 int filesize;
162 int retval;
163 retval = fileio_size(fileio, &filesize);
164 if (retval != ERROR_OK)
165 return retval;
166
167 ihex->buffer = malloc(filesize >> 1);
168 cooked_bytes = 0x0;
169 image->num_sections = 0;
170 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
171 section[image->num_sections].base_address = 0x0;
172 section[image->num_sections].size = 0x0;
173 section[image->num_sections].flags = 0;
174
175 while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
176 {
177 uint32_t count;
178 uint32_t address;
179 uint32_t record_type;
180 uint32_t checksum;
181 uint8_t cal_checksum = 0;
182 size_t bytes_read = 0;
183
184 if (sscanf(&lpszLine[bytes_read], ":%2" SCNx32 "%4" SCNx32 "%2" SCNx32 , &count, &address, &record_type) != 3)
185 {
186 return ERROR_IMAGE_FORMAT_ERROR;
187 }
188 bytes_read += 9;
189
190 cal_checksum += (uint8_t)count;
191 cal_checksum += (uint8_t)(address >> 8);
192 cal_checksum += (uint8_t)address;
193 cal_checksum += (uint8_t)record_type;
194
195 if (record_type == 0) /* Data Record */
196 {
197 if ((full_address & 0xffff) != address)
198 {
199 /* we encountered a nonconsecutive location, create a new section,
200 * unless the current section has zero size, in which case this specifies
201 * the current section's base address
202 */
203 if (section[image->num_sections].size != 0)
204 {
205 image->num_sections++;
206 if (image->num_sections >= IMAGE_MAX_SECTIONS)
207 {
208 /* too many sections */
209 LOG_ERROR("Too many sections found in IHEX file");
210 return ERROR_IMAGE_FORMAT_ERROR;
211 }
212 section[image->num_sections].size = 0x0;
213 section[image->num_sections].flags = 0;
214 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
215 }
216 section[image->num_sections].base_address =
217 (full_address & 0xffff0000) | address;
218 full_address = (full_address & 0xffff0000) | address;
219 }
220
221 while (count-- > 0)
222 {
223 unsigned value;
224 sscanf(&lpszLine[bytes_read], "%2x", &value);
225 ihex->buffer[cooked_bytes] = (uint8_t)value;
226 cal_checksum += (uint8_t)ihex->buffer[cooked_bytes];
227 bytes_read += 2;
228 cooked_bytes += 1;
229 section[image->num_sections].size += 1;
230 full_address++;
231 }
232 }
233 else if (record_type == 1) /* End of File Record */
234 {
235 /* finish the current section */
236 image->num_sections++;
237
238 /* copy section information */
239 image->sections = malloc(sizeof(struct imagesection) * image->num_sections);
240 for (i = 0; i < image->num_sections; i++)
241 {
242 image->sections[i].private = section[i].private;
243 image->sections[i].base_address = section[i].base_address;
244 image->sections[i].size = section[i].size;
245 image->sections[i].flags = section[i].flags;
246 }
247
248 return ERROR_OK;
249 }
250 else if (record_type == 2) /* Linear Address Record */
251 {
252 uint16_t upper_address;
253
254 sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
255 cal_checksum += (uint8_t)(upper_address >> 8);
256 cal_checksum += (uint8_t)upper_address;
257 bytes_read += 4;
258
259 if ((full_address >> 4) != upper_address)
260 {
261 /* we encountered a nonconsecutive location, create a new section,
262 * unless the current section has zero size, in which case this specifies
263 * the current section's base address
264 */
265 if (section[image->num_sections].size != 0)
266 {
267 image->num_sections++;
268 if (image->num_sections >= IMAGE_MAX_SECTIONS)
269 {
270 /* too many sections */
271 LOG_ERROR("Too many sections found in IHEX file");
272 return ERROR_IMAGE_FORMAT_ERROR;
273 }
274 section[image->num_sections].size = 0x0;
275 section[image->num_sections].flags = 0;
276 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
277 }
278 section[image->num_sections].base_address =
279 (full_address & 0xffff) | (upper_address << 4);
280 full_address = (full_address & 0xffff) | (upper_address << 4);
281 }
282 }
283 else if (record_type == 3) /* Start Segment Address Record */
284 {
285 uint32_t dummy;
286
287 /* "Start Segment Address Record" will not be supported */
288 /* but we must consume it, and do not create an error. */
289 while (count-- > 0)
290 {
291 sscanf(&lpszLine[bytes_read], "%2" SCNx32 , &dummy);
292 cal_checksum += (uint8_t)dummy;
293 bytes_read += 2;
294 }
295 }
296 else if (record_type == 4) /* Extended Linear Address Record */
297 {
298 uint16_t upper_address;
299
300 sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
301 cal_checksum += (uint8_t)(upper_address >> 8);
302 cal_checksum += (uint8_t)upper_address;
303 bytes_read += 4;
304
305 if ((full_address >> 16) != upper_address)
306 {
307 /* we encountered a nonconsecutive location, create a new section,
308 * unless the current section has zero size, in which case this specifies
309 * the current section's base address
310 */
311 if (section[image->num_sections].size != 0)
312 {
313 image->num_sections++;
314 if (image->num_sections >= IMAGE_MAX_SECTIONS)
315 {
316 /* too many sections */
317 LOG_ERROR("Too many sections found in IHEX file");
318 return ERROR_IMAGE_FORMAT_ERROR;
319 }
320 section[image->num_sections].size = 0x0;
321 section[image->num_sections].flags = 0;
322 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
323 }
324 section[image->num_sections].base_address =
325 (full_address & 0xffff) | (upper_address << 16);
326 full_address = (full_address & 0xffff) | (upper_address << 16);
327 }
328 }
329 else if (record_type == 5) /* Start Linear Address Record */
330 {
331 uint32_t start_address;
332
333 sscanf(&lpszLine[bytes_read], "%8" SCNx32, &start_address);
334 cal_checksum += (uint8_t)(start_address >> 24);
335 cal_checksum += (uint8_t)(start_address >> 16);
336 cal_checksum += (uint8_t)(start_address >> 8);
337 cal_checksum += (uint8_t)start_address;
338 bytes_read += 8;
339
340 image->start_address_set = 1;
341 image->start_address = be_to_h_u32((uint8_t*)&start_address);
342 }
343 else
344 {
345 LOG_ERROR("unhandled IHEX record type: %i", (int)record_type);
346 return ERROR_IMAGE_FORMAT_ERROR;
347 }
348
349 sscanf(&lpszLine[bytes_read], "%2" SCNx32 , &checksum);
350 bytes_read += 2;
351
352 if ((uint8_t)checksum != (uint8_t)(~cal_checksum + 1))
353 {
354 /* checksum failed */
355 LOG_ERROR("incorrect record checksum found in IHEX file");
356 return ERROR_IMAGE_CHECKSUM;
357 }
358 }
359
360 LOG_ERROR("premature end of IHEX file, no end-of-file record found");
361 return ERROR_IMAGE_FORMAT_ERROR;
362 }
363
364 /**
365 * Allocate memory dynamically instead of on the stack. This
366 * is important w/embedded hosts.
367 */
368 static int image_ihex_buffer_complete(struct image *image)
369 {
370 char *lpszLine = malloc(1023);
371 if (lpszLine == NULL)
372 {
373 LOG_ERROR("Out of memory");
374 return ERROR_FAIL;
375 }
376 struct imagesection *section = malloc(sizeof(struct imagesection) * IMAGE_MAX_SECTIONS);
377 if (section == NULL)
378 {
379 free(lpszLine);
380 LOG_ERROR("Out of memory");
381 return ERROR_FAIL;
382 }
383 int retval;
384
385 retval = image_ihex_buffer_complete_inner(image, lpszLine, section);
386
387 free(section);
388 free(lpszLine);
389
390 return retval;
391 }
392
393 static int image_elf_read_headers(struct image *image)
394 {
395 struct image_elf *elf = image->type_private;
396 size_t read_bytes;
397 uint32_t i,j;
398 int retval;
399
400 elf->header = malloc(sizeof(Elf32_Ehdr));
401
402 if (elf->header == NULL)
403 {
404 LOG_ERROR("insufficient memory to perform operation ");
405 return ERROR_FILEIO_OPERATION_FAILED;
406 }
407
408 if ((retval = fileio_read(&elf->fileio, sizeof(Elf32_Ehdr), (uint8_t*)elf->header, &read_bytes)) != ERROR_OK)
409 {
410 LOG_ERROR("cannot read ELF file header, read failed");
411 return ERROR_FILEIO_OPERATION_FAILED;
412 }
413 if (read_bytes != sizeof(Elf32_Ehdr))
414 {
415 LOG_ERROR("cannot read ELF file header, only partially read");
416 return ERROR_FILEIO_OPERATION_FAILED;
417 }
418
419 if (strncmp((char*)elf->header->e_ident,ELFMAG,SELFMAG) != 0)
420 {
421 LOG_ERROR("invalid ELF file, bad magic number");
422 return ERROR_IMAGE_FORMAT_ERROR;
423 }
424 if (elf->header->e_ident[EI_CLASS]!=ELFCLASS32)
425 {
426 LOG_ERROR("invalid ELF file, only 32bits files are supported");
427 return ERROR_IMAGE_FORMAT_ERROR;
428 }
429
430 elf->endianness = elf->header->e_ident[EI_DATA];
431 if ((elf->endianness != ELFDATA2LSB)
432 &&(elf->endianness != ELFDATA2MSB))
433 {
434 LOG_ERROR("invalid ELF file, unknown endianess setting");
435 return ERROR_IMAGE_FORMAT_ERROR;
436 }
437
438 elf->segment_count = field16(elf,elf->header->e_phnum);
439 if (elf->segment_count == 0)
440 {
441 LOG_ERROR("invalid ELF file, no program headers");
442 return ERROR_IMAGE_FORMAT_ERROR;
443 }
444
445 if ((retval = fileio_seek(&elf->fileio, field32(elf,elf->header->e_phoff))) != ERROR_OK)
446 {
447 LOG_ERROR("cannot seek to ELF program header table, read failed");
448 return retval;
449 }
450
451 elf->segments = malloc(elf->segment_count*sizeof(Elf32_Phdr));
452 if (elf->segments == NULL)
453 {
454 LOG_ERROR("insufficient memory to perform operation ");
455 return ERROR_FILEIO_OPERATION_FAILED;
456 }
457
458 if ((retval = fileio_read(&elf->fileio, elf->segment_count*sizeof(Elf32_Phdr), (uint8_t*)elf->segments, &read_bytes)) != ERROR_OK)
459 {
460 LOG_ERROR("cannot read ELF segment headers, read failed");
461 return retval;
462 }
463 if (read_bytes != elf->segment_count*sizeof(Elf32_Phdr))
464 {
465 LOG_ERROR("cannot read ELF segment headers, only partially read");
466 return ERROR_FILEIO_OPERATION_FAILED;
467 }
468
469 /* count useful segments (loadable), ignore BSS section */
470 image->num_sections = 0;
471 for (i = 0;i < elf->segment_count;i++)
472 if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
473 image->num_sections++;
474 /* alloc and fill sections array with loadable segments */
475 image->sections = malloc(image->num_sections * sizeof(struct imagesection));
476 for (i = 0,j = 0;i < elf->segment_count;i++)
477 {
478 if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
479 {
480 image->sections[j].size = field32(elf,elf->segments[i].p_filesz);
481 image->sections[j].base_address = field32(elf,elf->segments[i].p_paddr);
482 image->sections[j].private = &elf->segments[i];
483 image->sections[j].flags = field32(elf,elf->segments[i].p_flags);
484 j++;
485 }
486 }
487
488 image->start_address_set = 1;
489 image->start_address = field32(elf,elf->header->e_entry);
490
491 return ERROR_OK;
492 }
493
494 static int image_elf_read_section(struct image *image, int section, uint32_t offset, uint32_t size, uint8_t *buffer, size_t *size_read)
495 {
496 struct image_elf *elf = image->type_private;
497 Elf32_Phdr *segment = (Elf32_Phdr *)image->sections[section].private;
498 size_t read_size,really_read;
499 int retval;
500
501 *size_read = 0;
502
503 LOG_DEBUG("load segment %d at 0x%" PRIx32 " (sz = 0x%" PRIx32 ")",section,offset,size);
504
505 /* read initialized data in current segment if any */
506 if (offset < field32(elf,segment->p_filesz))
507 {
508 /* maximal size present in file for the current segment */
509 read_size = MIN(size, field32(elf,segment->p_filesz)-offset);
510 LOG_DEBUG("read elf: size = 0x%zu at 0x%" PRIx32 "", read_size,
511 field32(elf,segment->p_offset) + offset);
512 /* read initialized area of the segment */
513 if ((retval = fileio_seek(&elf->fileio, field32(elf,segment->p_offset) + offset)) != ERROR_OK)
514 {
515 LOG_ERROR("cannot find ELF segment content, seek failed");
516 return retval;
517 }
518 if ((retval = fileio_read(&elf->fileio, read_size, buffer, &really_read)) != ERROR_OK)
519 {
520 LOG_ERROR("cannot read ELF segment content, read failed");
521 return retval;
522 }
523 buffer += read_size;
524 size -= read_size;
525 offset += read_size;
526 *size_read += read_size;
527 /* need more data ? */
528 if (!size)
529 return ERROR_OK;
530 }
531
532 return ERROR_OK;
533 }
534
535 static int image_mot_buffer_complete_inner(struct image *image, char *lpszLine, struct imagesection *section)
536 {
537 struct image_mot *mot = image->type_private;
538 struct fileio *fileio = &mot->fileio;
539 uint32_t full_address = 0x0;
540 uint32_t cooked_bytes;
541 int i;
542
543 /* we can't determine the number of sections that we'll have to create ahead of time,
544 * so we locally hold them until parsing is finished */
545
546 int retval;
547 int filesize;
548 retval = fileio_size(fileio, &filesize);
549 if (retval != ERROR_OK)
550 return retval;
551
552 mot->buffer = malloc(filesize >> 1);
553 cooked_bytes = 0x0;
554 image->num_sections = 0;
555 section[image->num_sections].private = &mot->buffer[cooked_bytes];
556 section[image->num_sections].base_address = 0x0;
557 section[image->num_sections].size = 0x0;
558 section[image->num_sections].flags = 0;
559
560 while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
561 {
562 uint32_t count;
563 uint32_t address;
564 uint32_t record_type;
565 uint32_t checksum;
566 uint8_t cal_checksum = 0;
567 uint32_t bytes_read = 0;
568
569 /* get record type and record length */
570 if (sscanf(&lpszLine[bytes_read], "S%1" SCNx32 "%2" SCNx32 , &record_type, &count) != 2)
571 {
572 return ERROR_IMAGE_FORMAT_ERROR;
573 }
574
575 bytes_read += 4;
576 cal_checksum += (uint8_t)count;
577
578 /* skip checksum byte */
579 count -=1;
580
581 if (record_type == 0)
582 {
583 /* S0 - starting record (optional) */
584 int iValue;
585
586 while (count-- > 0) {
587 sscanf(&lpszLine[bytes_read], "%2x", &iValue);
588 cal_checksum += (uint8_t)iValue;
589 bytes_read += 2;
590 }
591 }
592 else if (record_type >= 1 && record_type <= 3)
593 {
594 switch (record_type)
595 {
596 case 1:
597 /* S1 - 16 bit address data record */
598 sscanf(&lpszLine[bytes_read], "%4" SCNx32, &address);
599 cal_checksum += (uint8_t)(address >> 8);
600 cal_checksum += (uint8_t)address;
601 bytes_read += 4;
602 count -=2;
603 break;
604
605 case 2:
606 /* S2 - 24 bit address data record */
607 sscanf(&lpszLine[bytes_read], "%6" SCNx32 , &address);
608 cal_checksum += (uint8_t)(address >> 16);
609 cal_checksum += (uint8_t)(address >> 8);
610 cal_checksum += (uint8_t)address;
611 bytes_read += 6;
612 count -=3;
613 break;
614
615 case 3:
616 /* S3 - 32 bit address data record */
617 sscanf(&lpszLine[bytes_read], "%8" SCNx32 , &address);
618 cal_checksum += (uint8_t)(address >> 24);
619 cal_checksum += (uint8_t)(address >> 16);
620 cal_checksum += (uint8_t)(address >> 8);
621 cal_checksum += (uint8_t)address;
622 bytes_read += 8;
623 count -=4;
624 break;
625
626 }
627
628 if (full_address != address)
629 {
630 /* we encountered a nonconsecutive location, create a new section,
631 * unless the current section has zero size, in which case this specifies
632 * the current section's base address
633 */
634 if (section[image->num_sections].size != 0)
635 {
636 image->num_sections++;
637 section[image->num_sections].size = 0x0;
638 section[image->num_sections].flags = 0;
639 section[image->num_sections].private = &mot->buffer[cooked_bytes];
640 }
641 section[image->num_sections].base_address = address;
642 full_address = address;
643 }
644
645 while (count-- > 0)
646 {
647 unsigned value;
648 sscanf(&lpszLine[bytes_read], "%2x", &value);
649 mot->buffer[cooked_bytes] = (uint8_t)value;
650 cal_checksum += (uint8_t)mot->buffer[cooked_bytes];
651 bytes_read += 2;
652 cooked_bytes += 1;
653 section[image->num_sections].size += 1;
654 full_address++;
655 }
656 }
657 else if (record_type == 5)
658 {
659 /* S5 is the data count record, we ignore it */
660 uint32_t dummy;
661
662 while (count-- > 0)
663 {
664 sscanf(&lpszLine[bytes_read], "%2" SCNx32 , &dummy);
665 cal_checksum += (uint8_t)dummy;
666 bytes_read += 2;
667 }
668 }
669 else if (record_type >= 7 && record_type <= 9)
670 {
671 /* S7, S8, S9 - ending records for 32, 24 and 16bit */
672 image->num_sections++;
673
674 /* copy section information */
675 image->sections = malloc(sizeof(struct imagesection) * image->num_sections);
676 for (i = 0; i < image->num_sections; i++)
677 {
678 image->sections[i].private = section[i].private;
679 image->sections[i].base_address = section[i].base_address;
680 image->sections[i].size = section[i].size;
681 image->sections[i].flags = section[i].flags;
682 }
683
684 return ERROR_OK;
685 }
686 else
687 {
688 LOG_ERROR("unhandled S19 record type: %i", (int)(record_type));
689 return ERROR_IMAGE_FORMAT_ERROR;
690 }
691
692 /* account for checksum, will always be 0xFF */
693 sscanf(&lpszLine[bytes_read], "%2" SCNx32 , &checksum);
694 cal_checksum += (uint8_t)checksum;
695 bytes_read += 2;
696
697 if (cal_checksum != 0xFF)
698 {
699 /* checksum failed */
700 LOG_ERROR("incorrect record checksum found in S19 file");
701 return ERROR_IMAGE_CHECKSUM;
702 }
703 }
704
705 LOG_ERROR("premature end of S19 file, no end-of-file record found");
706 return ERROR_IMAGE_FORMAT_ERROR;
707 }
708
709 /**
710 * Allocate memory dynamically instead of on the stack. This
711 * is important w/embedded hosts.
712 */
713 static int image_mot_buffer_complete(struct image *image)
714 {
715 char *lpszLine = malloc(1023);
716 if (lpszLine == NULL)
717 {
718 LOG_ERROR("Out of memory");
719 return ERROR_FAIL;
720 }
721 struct imagesection *section = malloc(sizeof(struct imagesection) * IMAGE_MAX_SECTIONS);
722 if (section == NULL)
723 {
724 free(lpszLine);
725 LOG_ERROR("Out of memory");
726 return ERROR_FAIL;
727 }
728 int retval;
729
730 retval = image_mot_buffer_complete_inner(image, lpszLine, section);
731
732 free(section);
733 free(lpszLine);
734
735 return retval;
736 }
737
738
739 int image_open(struct image *image, const char *url, const char *type_string)
740 {
741 int retval = ERROR_OK;
742
743 if ((retval = identify_image_type(image, type_string, url)) != ERROR_OK)
744 {
745 return retval;
746 }
747
748 if (image->type == IMAGE_BINARY)
749 {
750 struct image_binary *image_binary;
751
752 image_binary = image->type_private = malloc(sizeof(struct image_binary));
753
754 if ((retval = fileio_open(&image_binary->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
755 {
756 return retval;
757 }
758 int filesize;
759 retval = fileio_size(&image_binary->fileio, &filesize);
760 if (retval != ERROR_OK)
761 {
762 fileio_close(&image_binary->fileio);
763 return retval;
764 }
765
766 image->num_sections = 1;
767 image->sections = malloc(sizeof(struct imagesection));
768 image->sections[0].base_address = 0x0;
769 image->sections[0].size = filesize;
770 image->sections[0].flags = 0;
771 }
772 else if (image->type == IMAGE_IHEX)
773 {
774 struct image_ihex *image_ihex;
775
776 image_ihex = image->type_private = malloc(sizeof(struct image_ihex));
777
778 if ((retval = fileio_open(&image_ihex->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
779 {
780 return retval;
781 }
782
783 if ((retval = image_ihex_buffer_complete(image)) != ERROR_OK)
784 {
785 LOG_ERROR("failed buffering IHEX image, check daemon output for additional information");
786 fileio_close(&image_ihex->fileio);
787 return retval;
788 }
789 }
790 else if (image->type == IMAGE_ELF)
791 {
792 struct image_elf *image_elf;
793
794 image_elf = image->type_private = malloc(sizeof(struct image_elf));
795
796 if ((retval = fileio_open(&image_elf->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
797 {
798 return retval;
799 }
800
801 if ((retval = image_elf_read_headers(image)) != ERROR_OK)
802 {
803 fileio_close(&image_elf->fileio);
804 return retval;
805 }
806 }
807 else if (image->type == IMAGE_MEMORY)
808 {
809 struct target *target = get_target(url);
810
811 if (target == NULL)
812 {
813 LOG_ERROR("target '%s' not defined", url);
814 return ERROR_FAIL;
815 }
816
817 struct image_memory *image_memory;
818
819 image->num_sections = 1;
820 image->sections = malloc(sizeof(struct imagesection));
821 image->sections[0].base_address = 0x0;
822 image->sections[0].size = 0xffffffff;
823 image->sections[0].flags = 0;
824
825 image_memory = image->type_private = malloc(sizeof(struct image_memory));
826
827 image_memory->target = target;
828 image_memory->cache = NULL;
829 image_memory->cache_address = 0x0;
830 }
831 else if (image->type == IMAGE_SRECORD)
832 {
833 struct image_mot *image_mot;
834
835 image_mot = image->type_private = malloc(sizeof(struct image_mot));
836
837 if ((retval = fileio_open(&image_mot->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
838 {
839 return retval;
840 }
841
842 if ((retval = image_mot_buffer_complete(image)) != ERROR_OK)
843 {
844 LOG_ERROR("failed buffering S19 image, check daemon output for additional information");
845 fileio_close(&image_mot->fileio);
846 return retval;
847 }
848 }
849 else if (image->type == IMAGE_BUILDER)
850 {
851 image->num_sections = 0;
852 image->sections = NULL;
853 image->type_private = NULL;
854 }
855
856 if (image->base_address_set)
857 {
858 /* relocate */
859 int section;
860 for (section = 0; section < image->num_sections; section++)
861 {
862 image->sections[section].base_address += image->base_address;
863 }
864 /* we're done relocating. The two statements below are mainly
865 * for documenation purposes: stop anyone from empirically
866 * thinking they should use these values henceforth. */
867 image->base_address = 0;
868 image->base_address_set = 0;
869 }
870
871 return retval;
872 };
873
874 int image_read_section(struct image *image, int section, uint32_t offset, uint32_t size, uint8_t *buffer, size_t *size_read)
875 {
876 int retval;
877
878 /* don't read past the end of a section */
879 if (offset + size > image->sections[section].size)
880 {
881 LOG_DEBUG("read past end of section: 0x%8.8" PRIx32 " + 0x%8.8" PRIx32 " > 0x%8.8" PRIx32 "",
882 offset, size, image->sections[section].size);
883 return ERROR_INVALID_ARGUMENTS;
884 }
885
886 if (image->type == IMAGE_BINARY)
887 {
888 struct image_binary *image_binary = image->type_private;
889
890 /* only one section in a plain binary */
891 if (section != 0)
892 return ERROR_INVALID_ARGUMENTS;
893
894 /* seek to offset */
895 if ((retval = fileio_seek(&image_binary->fileio, offset)) != ERROR_OK)
896 {
897 return retval;
898 }
899
900 /* return requested bytes */
901 if ((retval = fileio_read(&image_binary->fileio, size, buffer, size_read)) != ERROR_OK)
902 {
903 return retval;
904 }
905 }
906 else if (image->type == IMAGE_IHEX)
907 {
908 memcpy(buffer, (uint8_t*)image->sections[section].private + offset, size);
909 *size_read = size;
910
911 return ERROR_OK;
912 }
913 else if (image->type == IMAGE_ELF)
914 {
915 return image_elf_read_section(image, section, offset, size, buffer, size_read);
916 }
917 else if (image->type == IMAGE_MEMORY)
918 {
919 struct image_memory *image_memory = image->type_private;
920 uint32_t address = image->sections[section].base_address + offset;
921
922 *size_read = 0;
923
924 while ((size - *size_read) > 0)
925 {
926 uint32_t size_in_cache;
927
928 if (!image_memory->cache
929 || (address < image_memory->cache_address)
930 || (address >= (image_memory->cache_address + IMAGE_MEMORY_CACHE_SIZE)))
931 {
932 if (!image_memory->cache)
933 image_memory->cache = malloc(IMAGE_MEMORY_CACHE_SIZE);
934
935 if (target_read_buffer(image_memory->target, address & ~(IMAGE_MEMORY_CACHE_SIZE - 1),
936 IMAGE_MEMORY_CACHE_SIZE, image_memory->cache) != ERROR_OK)
937 {
938 free(image_memory->cache);
939 image_memory->cache = NULL;
940 return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE;
941 }
942 image_memory->cache_address = address & ~(IMAGE_MEMORY_CACHE_SIZE - 1);
943 }
944
945 size_in_cache = (image_memory->cache_address + IMAGE_MEMORY_CACHE_SIZE) - address;
946
947 memcpy(buffer + *size_read,
948 image_memory->cache + (address - image_memory->cache_address),
949 (size_in_cache > size) ? size : size_in_cache
950 );
951
952 *size_read += (size_in_cache > size) ? size : size_in_cache;
953 address += (size_in_cache > size) ? size : size_in_cache;
954 }
955 }
956 else if (image->type == IMAGE_SRECORD)
957 {
958 memcpy(buffer, (uint8_t*)image->sections[section].private + offset, size);
959 *size_read = size;
960
961 return ERROR_OK;
962 }
963 else if (image->type == IMAGE_BUILDER)
964 {
965 memcpy(buffer, (uint8_t*)image->sections[section].private + offset, size);
966 *size_read = size;
967
968 return ERROR_OK;
969 }
970
971 return ERROR_OK;
972 }
973
974 int image_add_section(struct image *image, uint32_t base, uint32_t size, int flags, uint8_t *data)
975 {
976 struct imagesection *section;
977
978 /* only image builder supports adding sections */
979 if (image->type != IMAGE_BUILDER)
980 return ERROR_INVALID_ARGUMENTS;
981
982 /* see if there's a previous section */
983 if (image->num_sections)
984 {
985 section = &image->sections[image->num_sections - 1];
986
987 /* see if it's enough to extend the last section,
988 * adding data to previous sections or merging is not supported */
989 if (((section->base_address + section->size) == base) && (section->flags == flags))
990 {
991 section->private = realloc(section->private, section->size + size);
992 memcpy((uint8_t*)section->private + section->size, data, size);
993 section->size += size;
994 return ERROR_OK;
995 }
996 }
997
998 /* allocate new section */
999 image->num_sections++;
1000 image->sections = realloc(image->sections, sizeof(struct imagesection) * image->num_sections);
1001 section = &image->sections[image->num_sections - 1];
1002 section->base_address = base;
1003 section->size = size;
1004 section->flags = flags;
1005 section->private = malloc(sizeof(uint8_t) * size);
1006 memcpy((uint8_t*)section->private, data, size);
1007
1008 return ERROR_OK;
1009 }
1010
1011 void image_close(struct image *image)
1012 {
1013 if (image->type == IMAGE_BINARY)
1014 {
1015 struct image_binary *image_binary = image->type_private;
1016
1017 fileio_close(&image_binary->fileio);
1018 }
1019 else if (image->type == IMAGE_IHEX)
1020 {
1021 struct image_ihex *image_ihex = image->type_private;
1022
1023 fileio_close(&image_ihex->fileio);
1024
1025 if (image_ihex->buffer)
1026 {
1027 free(image_ihex->buffer);
1028 image_ihex->buffer = NULL;
1029 }
1030 }
1031 else if (image->type == IMAGE_ELF)
1032 {
1033 struct image_elf *image_elf = image->type_private;
1034
1035 fileio_close(&image_elf->fileio);
1036
1037 if (image_elf->header)
1038 {
1039 free(image_elf->header);
1040 image_elf->header = NULL;
1041 }
1042
1043 if (image_elf->segments)
1044 {
1045 free(image_elf->segments);
1046 image_elf->segments = NULL;
1047 }
1048 }
1049 else if (image->type == IMAGE_MEMORY)
1050 {
1051 struct image_memory *image_memory = image->type_private;
1052
1053 if (image_memory->cache)
1054 {
1055 free(image_memory->cache);
1056 image_memory->cache = NULL;
1057 }
1058 }
1059 else if (image->type == IMAGE_SRECORD)
1060 {
1061 struct image_mot *image_mot = image->type_private;
1062
1063 fileio_close(&image_mot->fileio);
1064
1065 if (image_mot->buffer)
1066 {
1067 free(image_mot->buffer);
1068 image_mot->buffer = NULL;
1069 }
1070 }
1071 else if (image->type == IMAGE_BUILDER)
1072 {
1073 int i;
1074
1075 for (i = 0; i < image->num_sections; i++)
1076 {
1077 free(image->sections[i].private);
1078 image->sections[i].private = NULL;
1079 }
1080 }
1081
1082 if (image->type_private)
1083 {
1084 free(image->type_private);
1085 image->type_private = NULL;
1086 }
1087
1088 if (image->sections)
1089 {
1090 free(image->sections);
1091 image->sections = NULL;
1092 }
1093 }
1094
1095 int image_calculate_checksum(uint8_t* buffer, uint32_t nbytes, uint32_t* checksum)
1096 {
1097 uint32_t crc = 0xffffffff;
1098 LOG_DEBUG("Calculating checksum");
1099
1100 static uint32_t crc32_table[256];
1101
1102 static bool first_init = false;
1103 if (!first_init)
1104 {
1105 /* Initialize the CRC table and the decoding table. */
1106 int i, j;
1107 unsigned int c;
1108 for (i = 0; i < 256; i++)
1109 {
1110 /* as per gdb */
1111 for (c = i << 24, j = 8; j > 0; --j)
1112 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
1113 crc32_table[i] = c;
1114 }
1115
1116 first_init = true;
1117 }
1118
1119 while (nbytes > 0)
1120 {
1121 int run = nbytes;
1122 if (run > 32768)
1123 {
1124 run = 32768;
1125 }
1126 nbytes -= run;
1127 while (run--)
1128 {
1129 /* as per gdb */
1130 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buffer++) & 255];
1131 }
1132 keep_alive();
1133 }
1134
1135 LOG_DEBUG("Calculating checksum done");
1136
1137 *checksum = crc;
1138 return ERROR_OK;
1139 }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)