X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Fimage.c;h=b0d957f8ab62164f7d9a1d63be442655ef2393f0;hp=40b320fad76f78b4d2cbbc56ed88fb3a832fe235;hb=3931b99d142d337ea6558fd09aad2e0812c04507;hpb=8959de9f679cfd0436d731fd91b88a68b9a75fa6 diff --git a/src/target/image.c b/src/target/image.c index 40b320fad7..b0d957f8ab 100644 --- a/src/target/image.c +++ b/src/target/image.c @@ -2,12 +2,15 @@ * Copyright (C) 2007 by Dominic Rath * * Dominic.Rath@gmx.de * * * - * Copyright (C) 2007,2008 Øyvind Harboe * + * Copyright (C) 2007,2008 Øyvind Harboe * * oyvind.harboe@zylin.com * * * * Copyright (C) 2008 by Spencer Oliver * * spen@spen-soft.co.uk * * * + * Copyright (C) 2009 by Franck Hereson * + * franck.hereson@secad.fr * + * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * @@ -29,7 +32,7 @@ #include "image.h" #include "target.h" -#include "log.h" +#include /* convert ELF header field to host endianness */ @@ -41,11 +44,11 @@ ((elf->endianness == ELFDATA2LSB)? \ le_to_h_u32((uint8_t*)&field):be_to_h_u32((uint8_t*)&field)) -static int autodetect_image_type(image_t *image, char *url) +static int autodetect_image_type(struct image *image, const char *url) { int retval; - fileio_t fileio; - uint32_t read_bytes; + struct fileio fileio; + size_t read_bytes; uint8_t buffer[9]; /* read the first 4 bytes of image */ @@ -103,7 +106,7 @@ static int autodetect_image_type(image_t *image, char *url) return ERROR_OK; } -static int identify_image_type(image_t *image, char *type_string, char *url) +static int identify_image_type(struct image *image, const char *type_string, const char *url) { if (type_string) { @@ -144,20 +147,24 @@ static int identify_image_type(image_t *image, char *type_string, char *url) return ERROR_OK; } -static int image_ihex_buffer_complete(image_t *image) +static int image_ihex_buffer_complete_inner(struct image *image, char *lpszLine, struct imagesection *section) { - image_ihex_t *ihex = image->type_private; - fileio_t *fileio = &ihex->fileio; + struct image_ihex *ihex = image->type_private; + struct fileio *fileio = &ihex->fileio; uint32_t full_address = 0x0; uint32_t cooked_bytes; int i; - char lpszLine[1023]; /* we can't determine the number of sections that we'll have to create ahead of time, * so we locally hold them until parsing is finished */ - image_section_t section[IMAGE_MAX_SECTIONS]; - ihex->buffer = malloc(fileio->size >> 1); + int filesize; + int retval; + retval = fileio_size(fileio, &filesize); + if (retval != ERROR_OK) + return retval; + + ihex->buffer = malloc(filesize >> 1); cooked_bytes = 0x0; image->num_sections = 0; section[image->num_sections].private = &ihex->buffer[cooked_bytes]; @@ -172,7 +179,7 @@ static int image_ihex_buffer_complete(image_t *image) uint32_t record_type; uint32_t checksum; uint8_t cal_checksum = 0; - uint32_t bytes_read = 0; + size_t bytes_read = 0; if (sscanf(&lpszLine[bytes_read], ":%2" SCNx32 "%4" SCNx32 "%2" SCNx32 , &count, &address, &record_type) != 3) { @@ -196,6 +203,12 @@ static int image_ihex_buffer_complete(image_t *image) if (section[image->num_sections].size != 0) { image->num_sections++; + if (image->num_sections >= IMAGE_MAX_SECTIONS) + { + /* too many sections */ + LOG_ERROR("Too many sections found in IHEX file"); + return ERROR_IMAGE_FORMAT_ERROR; + } section[image->num_sections].size = 0x0; section[image->num_sections].flags = 0; section[image->num_sections].private = &ihex->buffer[cooked_bytes]; @@ -223,7 +236,7 @@ static int image_ihex_buffer_complete(image_t *image) image->num_sections++; /* copy section information */ - image->sections = malloc(sizeof(image_section_t) * image->num_sections); + image->sections = malloc(sizeof(struct imagesection) * image->num_sections); for (i = 0; i < image->num_sections; i++) { image->sections[i].private = section[i].private; @@ -252,6 +265,12 @@ static int image_ihex_buffer_complete(image_t *image) if (section[image->num_sections].size != 0) { image->num_sections++; + if (image->num_sections >= IMAGE_MAX_SECTIONS) + { + /* too many sections */ + LOG_ERROR("Too many sections found in IHEX file"); + return ERROR_IMAGE_FORMAT_ERROR; + } section[image->num_sections].size = 0x0; section[image->num_sections].flags = 0; section[image->num_sections].private = &ihex->buffer[cooked_bytes]; @@ -292,6 +311,12 @@ static int image_ihex_buffer_complete(image_t *image) if (section[image->num_sections].size != 0) { image->num_sections++; + if (image->num_sections >= IMAGE_MAX_SECTIONS) + { + /* too many sections */ + LOG_ERROR("Too many sections found in IHEX file"); + return ERROR_IMAGE_FORMAT_ERROR; + } section[image->num_sections].size = 0x0; section[image->num_sections].flags = 0; section[image->num_sections].private = &ihex->buffer[cooked_bytes]; @@ -336,10 +361,39 @@ static int image_ihex_buffer_complete(image_t *image) return ERROR_IMAGE_FORMAT_ERROR; } -static int image_elf_read_headers(image_t *image) +/** + * Allocate memory dynamically instead of on the stack. This + * is important w/embedded hosts. + */ +static int image_ihex_buffer_complete(struct image *image) { - image_elf_t *elf = image->type_private; - uint32_t read_bytes; + char *lpszLine = malloc(1023); + if (lpszLine == NULL) + { + LOG_ERROR("Out of memory"); + return ERROR_FAIL; + } + struct imagesection *section = malloc(sizeof(struct imagesection) * IMAGE_MAX_SECTIONS); + if (section == NULL) + { + free(lpszLine); + LOG_ERROR("Out of memory"); + return ERROR_FAIL; + } + int retval; + + retval = image_ihex_buffer_complete_inner(image, lpszLine, section); + + free(section); + free(lpszLine); + + return retval; +} + +static int image_elf_read_headers(struct image *image) +{ + struct image_elf *elf = image->type_private; + size_t read_bytes; uint32_t i,j; int retval; @@ -414,12 +468,12 @@ static int image_elf_read_headers(image_t *image) /* count useful segments (loadable), ignore BSS section */ image->num_sections = 0; - for (i = 0;isegment_count;i++) + for (i = 0;i < elf->segment_count;i++) if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0)) image->num_sections++; /* alloc and fill sections array with loadable segments */ - image->sections = malloc(image->num_sections * sizeof(image_section_t)); - for (i = 0,j = 0;isegment_count;i++) + image->sections = malloc(image->num_sections * sizeof(struct imagesection)); + for (i = 0,j = 0;i < elf->segment_count;i++) { if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0)) { @@ -437,11 +491,11 @@ static int image_elf_read_headers(image_t *image) return ERROR_OK; } -static int image_elf_read_section(image_t *image, int section, uint32_t offset, uint32_t size, uint8_t *buffer, uint32_t *size_read) +static int image_elf_read_section(struct image *image, int section, uint32_t offset, uint32_t size, uint8_t *buffer, size_t *size_read) { - image_elf_t *elf = image->type_private; + struct image_elf *elf = image->type_private; Elf32_Phdr *segment = (Elf32_Phdr *)image->sections[section].private; - uint32_t read_size,really_read; + size_t read_size,really_read; int retval; *size_read = 0; @@ -449,11 +503,11 @@ static int image_elf_read_section(image_t *image, int section, uint32_t offset, LOG_DEBUG("load segment %d at 0x%" PRIx32 " (sz = 0x%" PRIx32 ")",section,offset,size); /* read initialized data in current segment if any */ - if (offsetp_filesz)) + if (offset < field32(elf,segment->p_filesz)) { /* maximal size present in file for the current segment */ read_size = MIN(size, field32(elf,segment->p_filesz)-offset); - LOG_DEBUG("read elf: size = 0x%" PRIx32 " at 0x%" PRIx32 "",read_size, + LOG_DEBUG("read elf: size = 0x%zu at 0x%" PRIx32 "", read_size, field32(elf,segment->p_offset) + offset); /* read initialized area of the segment */ if ((retval = fileio_seek(&elf->fileio, field32(elf,segment->p_offset) + offset)) != ERROR_OK) @@ -478,20 +532,24 @@ static int image_elf_read_section(image_t *image, int section, uint32_t offset, return ERROR_OK; } -static int image_mot_buffer_complete(image_t *image) +static int image_mot_buffer_complete_inner(struct image *image, char *lpszLine, struct imagesection *section) { - image_mot_t *mot = image->type_private; - fileio_t *fileio = &mot->fileio; + struct image_mot *mot = image->type_private; + struct fileio *fileio = &mot->fileio; uint32_t full_address = 0x0; uint32_t cooked_bytes; int i; - char lpszLine[1023]; /* we can't determine the number of sections that we'll have to create ahead of time, * so we locally hold them until parsing is finished */ - image_section_t section[IMAGE_MAX_SECTIONS]; - mot->buffer = malloc(fileio->size >> 1); + int retval; + int filesize; + retval = fileio_size(fileio, &filesize); + if (retval != ERROR_OK) + return retval; + + mot->buffer = malloc(filesize >> 1); cooked_bytes = 0x0; image->num_sections = 0; section[image->num_sections].private = &mot->buffer[cooked_bytes]; @@ -533,7 +591,7 @@ static int image_mot_buffer_complete(image_t *image) } else if (record_type >= 1 && record_type <= 3) { - switch ( record_type ) + switch (record_type) { case 1: /* S1 - 16 bit address data record */ @@ -614,7 +672,7 @@ static int image_mot_buffer_complete(image_t *image) image->num_sections++; /* copy section information */ - image->sections = malloc(sizeof(image_section_t) * image->num_sections); + image->sections = malloc(sizeof(struct imagesection) * image->num_sections); for (i = 0; i < image->num_sections; i++) { image->sections[i].private = section[i].private; @@ -636,7 +694,7 @@ static int image_mot_buffer_complete(image_t *image) cal_checksum += (uint8_t)checksum; bytes_read += 2; - if ( cal_checksum != 0xFF ) + if (cal_checksum != 0xFF) { /* checksum failed */ LOG_ERROR("incorrect record checksum found in S19 file"); @@ -648,7 +706,37 @@ static int image_mot_buffer_complete(image_t *image) return ERROR_IMAGE_FORMAT_ERROR; } -int image_open(image_t *image, char *url, char *type_string) +/** + * Allocate memory dynamically instead of on the stack. This + * is important w/embedded hosts. + */ +static int image_mot_buffer_complete(struct image *image) +{ + char *lpszLine = malloc(1023); + if (lpszLine == NULL) + { + LOG_ERROR("Out of memory"); + return ERROR_FAIL; + } + struct imagesection *section = malloc(sizeof(struct imagesection) * IMAGE_MAX_SECTIONS); + if (section == NULL) + { + free(lpszLine); + LOG_ERROR("Out of memory"); + return ERROR_FAIL; + } + int retval; + + retval = image_mot_buffer_complete_inner(image, lpszLine, section); + + free(section); + free(lpszLine); + + return retval; +} + + +int image_open(struct image *image, const char *url, const char *type_string) { int retval = ERROR_OK; @@ -659,26 +747,33 @@ int image_open(image_t *image, char *url, char *type_string) if (image->type == IMAGE_BINARY) { - image_binary_t *image_binary; + struct image_binary *image_binary; - image_binary = image->type_private = malloc(sizeof(image_binary_t)); + image_binary = image->type_private = malloc(sizeof(struct image_binary)); if ((retval = fileio_open(&image_binary->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK) { return retval; } + int filesize; + retval = fileio_size(&image_binary->fileio, &filesize); + if (retval != ERROR_OK) + { + fileio_close(&image_binary->fileio); + return retval; + } image->num_sections = 1; - image->sections = malloc(sizeof(image_section_t)); + image->sections = malloc(sizeof(struct imagesection)); image->sections[0].base_address = 0x0; - image->sections[0].size = image_binary->fileio.size; + image->sections[0].size = filesize; image->sections[0].flags = 0; } else if (image->type == IMAGE_IHEX) { - image_ihex_t *image_ihex; + struct image_ihex *image_ihex; - image_ihex = image->type_private = malloc(sizeof(image_ihex_t)); + image_ihex = image->type_private = malloc(sizeof(struct image_ihex)); if ((retval = fileio_open(&image_ihex->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK) { @@ -694,9 +789,9 @@ int image_open(image_t *image, char *url, char *type_string) } else if (image->type == IMAGE_ELF) { - image_elf_t *image_elf; + struct image_elf *image_elf; - image_elf = image->type_private = malloc(sizeof(image_elf_t)); + image_elf = image->type_private = malloc(sizeof(struct image_elf)); if ((retval = fileio_open(&image_elf->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK) { @@ -711,7 +806,7 @@ int image_open(image_t *image, char *url, char *type_string) } else if (image->type == IMAGE_MEMORY) { - target_t *target = get_target(url); + struct target *target = get_target(url); if (target == NULL) { @@ -719,15 +814,15 @@ int image_open(image_t *image, char *url, char *type_string) return ERROR_FAIL; } - image_memory_t *image_memory; + struct image_memory *image_memory; image->num_sections = 1; - image->sections = malloc(sizeof(image_section_t)); + image->sections = malloc(sizeof(struct imagesection)); image->sections[0].base_address = 0x0; image->sections[0].size = 0xffffffff; image->sections[0].flags = 0; - image_memory = image->type_private = malloc(sizeof(image_memory_t)); + image_memory = image->type_private = malloc(sizeof(struct image_memory)); image_memory->target = target; image_memory->cache = NULL; @@ -735,9 +830,9 @@ int image_open(image_t *image, char *url, char *type_string) } else if (image->type == IMAGE_SRECORD) { - image_mot_t *image_mot; + struct image_mot *image_mot; - image_mot = image->type_private = malloc(sizeof(image_mot_t)); + image_mot = image->type_private = malloc(sizeof(struct image_mot)); if ((retval = fileio_open(&image_mot->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK) { @@ -776,7 +871,7 @@ int image_open(image_t *image, char *url, char *type_string) return retval; }; -int image_read_section(image_t *image, int section, uint32_t offset, uint32_t size, uint8_t *buffer, uint32_t *size_read) +int image_read_section(struct image *image, int section, uint32_t offset, uint32_t size, uint8_t *buffer, size_t *size_read) { int retval; @@ -790,7 +885,7 @@ int image_read_section(image_t *image, int section, uint32_t offset, uint32_t si if (image->type == IMAGE_BINARY) { - image_binary_t *image_binary = image->type_private; + struct image_binary *image_binary = image->type_private; /* only one section in a plain binary */ if (section != 0) @@ -821,7 +916,7 @@ int image_read_section(image_t *image, int section, uint32_t offset, uint32_t si } else if (image->type == IMAGE_MEMORY) { - image_memory_t *image_memory = image->type_private; + struct image_memory *image_memory = image->type_private; uint32_t address = image->sections[section].base_address + offset; *size_read = 0; @@ -852,7 +947,7 @@ int image_read_section(image_t *image, int section, uint32_t offset, uint32_t si memcpy(buffer + *size_read, image_memory->cache + (address - image_memory->cache_address), (size_in_cache > size) ? size : size_in_cache - ); +); *size_read += (size_in_cache > size) ? size : size_in_cache; address += (size_in_cache > size) ? size : size_in_cache; @@ -876,9 +971,9 @@ int image_read_section(image_t *image, int section, uint32_t offset, uint32_t si return ERROR_OK; } -int image_add_section(image_t *image, uint32_t base, uint32_t size, int flags, uint8_t *data) +int image_add_section(struct image *image, uint32_t base, uint32_t size, int flags, uint8_t *data) { - image_section_t *section; + struct imagesection *section; /* only image builder supports adding sections */ if (image->type != IMAGE_BUILDER) @@ -902,7 +997,7 @@ int image_add_section(image_t *image, uint32_t base, uint32_t size, int flags, u /* allocate new section */ image->num_sections++; - image->sections = realloc(image->sections, sizeof(image_section_t) * image->num_sections); + image->sections = realloc(image->sections, sizeof(struct imagesection) * image->num_sections); section = &image->sections[image->num_sections - 1]; section->base_address = base; section->size = size; @@ -913,17 +1008,17 @@ int image_add_section(image_t *image, uint32_t base, uint32_t size, int flags, u return ERROR_OK; } -void image_close(image_t *image) +void image_close(struct image *image) { if (image->type == IMAGE_BINARY) { - image_binary_t *image_binary = image->type_private; + struct image_binary *image_binary = image->type_private; fileio_close(&image_binary->fileio); } else if (image->type == IMAGE_IHEX) { - image_ihex_t *image_ihex = image->type_private; + struct image_ihex *image_ihex = image->type_private; fileio_close(&image_ihex->fileio); @@ -935,7 +1030,7 @@ void image_close(image_t *image) } else if (image->type == IMAGE_ELF) { - image_elf_t *image_elf = image->type_private; + struct image_elf *image_elf = image->type_private; fileio_close(&image_elf->fileio); @@ -953,7 +1048,7 @@ void image_close(image_t *image) } else if (image->type == IMAGE_MEMORY) { - image_memory_t *image_memory = image->type_private; + struct image_memory *image_memory = image->type_private; if (image_memory->cache) { @@ -963,7 +1058,7 @@ void image_close(image_t *image) } else if (image->type == IMAGE_SRECORD) { - image_mot_t *image_mot = image->type_private; + struct image_mot *image_mot = image->type_private; fileio_close(&image_mot->fileio); @@ -1002,23 +1097,29 @@ int image_calculate_checksum(uint8_t* buffer, uint32_t nbytes, uint32_t* checksu uint32_t crc = 0xffffffff; LOG_DEBUG("Calculating checksum"); - uint32_t crc32_table[256]; + static uint32_t crc32_table[256]; - /* Initialize the CRC table and the decoding table. */ - int i, j; - unsigned int c; - for (i = 0; i < 256; i++) + static bool first_init = false; + if (!first_init) { - /* as per gdb */ - for (c = i << 24, j = 8; j > 0; --j) - c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); - crc32_table[i] = c; + /* Initialize the CRC table and the decoding table. */ + int i, j; + unsigned int c; + for (i = 0; i < 256; i++) + { + /* as per gdb */ + for (c = i << 24, j = 8; j > 0; --j) + c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); + crc32_table[i] = c; + } + + first_init = true; } - while (nbytes>0) + while (nbytes > 0) { int run = nbytes; - if (run>32768) + if (run > 32768) { run = 32768; }