diff options
Diffstat (limited to 'drivers/staging/tidspbridge/dynload/tramp.c')
| -rw-r--r-- | drivers/staging/tidspbridge/dynload/tramp.c | 1143 |
1 files changed, 0 insertions, 1143 deletions
diff --git a/drivers/staging/tidspbridge/dynload/tramp.c b/drivers/staging/tidspbridge/dynload/tramp.c deleted file mode 100644 index 5f0431305fbb..000000000000 --- a/drivers/staging/tidspbridge/dynload/tramp.c +++ /dev/null @@ -1,1143 +0,0 @@ -/* - * tramp.c - * - * DSP-BIOS Bridge driver support functions for TI OMAP processors. - * - * Copyright (C) 2009 Texas Instruments, Inc. - * - * This package is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - * - * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED - * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. - */ - -#include "header.h" - -#if TMS32060 -#include "tramp_table_c6000.c" -#endif - -#define MAX_RELOS_PER_PASS 4 - -/* - * Function: priv_tramp_sect_tgt_alloc - * Description: Allocate target memory for the trampoline section. The - * target mem size is easily obtained as the next available address. - */ -static int priv_tramp_sect_tgt_alloc(struct dload_state *dlthis) -{ - int ret_val = 0; - struct ldr_section_info *sect_info; - - /* Populate the trampoline loader section and allocate it on the - * target. The section name is ALWAYS the first string in the final - * string table for trampolines. The trampoline section is always - * 1 beyond the total number of allocated sections. */ - sect_info = &dlthis->ldr_sections[dlthis->allocated_secn_count]; - - sect_info->name = dlthis->tramp.final_string_table; - sect_info->size = dlthis->tramp.tramp_sect_next_addr; - sect_info->context = 0; - sect_info->type = - (4 << 8) | DLOAD_TEXT | DS_ALLOCATE_MASK | DS_DOWNLOAD_MASK; - sect_info->page = 0; - sect_info->run_addr = 0; - sect_info->load_addr = 0; - ret_val = dlthis->myalloc->dload_allocate(dlthis->myalloc, - sect_info, - ds_alignment - (sect_info->type)); - - if (ret_val == 0) - dload_error(dlthis, "Failed to allocate target memory for" - " trampoline"); - - return ret_val; -} - -/* - * Function: priv_h2a - * Description: Helper function to convert a hex value to its ASCII - * representation. Used for trampoline symbol name generation. - */ -static u8 priv_h2a(u8 value) -{ - if (value > 0xF) - return 0xFF; - - if (value <= 9) - value += 0x30; - else - value += 0x37; - - return value; -} - -/* - * Function: priv_tramp_sym_gen_name - * Description: Generate a trampoline symbol name (ASCII) using the value - * of the symbol. This places the new name into the user buffer. - * The name is fixed in length and of the form: __$dbTR__xxxxxxxx - * (where "xxxxxxxx" is the hex value). - */ -static void priv_tramp_sym_gen_name(u32 value, char *dst) -{ - u32 i; - char *prefix = TRAMP_SYM_PREFIX; - char *dst_local = dst; - u8 tmp; - - /* Clear out the destination, including the ending NULL */ - for (i = 0; i < (TRAMP_SYM_PREFIX_LEN + TRAMP_SYM_HEX_ASCII_LEN); i++) - *(dst_local + i) = 0; - - /* Copy the prefix to start */ - for (i = 0; i < strlen(TRAMP_SYM_PREFIX); i++) { - *dst_local = *(prefix + i); - dst_local++; - } - - /* Now convert the value passed in to a string equiv of the hex */ - for (i = 0; i < sizeof(value); i++) { -#ifndef _BIG_ENDIAN - tmp = *(((u8 *) &value) + (sizeof(value) - 1) - i); - *dst_local = priv_h2a((tmp & 0xF0) >> 4); - dst_local++; - *dst_local = priv_h2a(tmp & 0x0F); - dst_local++; -#else - tmp = *(((u8 *) &value) + i); - *dst_local = priv_h2a((tmp & 0xF0) >> 4); - dst_local++; - *dst_local = priv_h2a(tmp & 0x0F); - dst_local++; -#endif - } - - /* NULL terminate */ - *dst_local = 0; -} - -/* - * Function: priv_tramp_string_create - * Description: Create a new string specific to the trampoline loading and add - * it to the trampoline string list. This list contains the - * trampoline section name and trampoline point symbols. - */ -static struct tramp_string *priv_tramp_string_create(struct dload_state *dlthis, - u32 str_len, char *str) -{ - struct tramp_string *new_string = NULL; - u32 i; - - /* Create a new string object with the specified size. */ - new_string = - (struct tramp_string *)dlthis->mysym->dload_allocate(dlthis->mysym, - (sizeof - (struct - tramp_string) - + str_len + - 1)); - if (new_string != NULL) { - /* Clear the string first. This ensures the ending NULL is - * present and the optimizer won't touch it. */ - for (i = 0; i < (sizeof(struct tramp_string) + str_len + 1); - i++) - *((u8 *) new_string + i) = 0; - - /* Add this string to our virtual table by assigning it the - * next index and pushing it to the tail of the list. */ - new_string->index = dlthis->tramp.tramp_string_next_index; - dlthis->tramp.tramp_string_next_index++; - dlthis->tramp.tramp_string_size += str_len + 1; - - new_string->next = NULL; - if (dlthis->tramp.string_head == NULL) - dlthis->tramp.string_head = new_string; - else - dlthis->tramp.string_tail->next = new_string; - - dlthis->tramp.string_tail = new_string; - - /* Copy the string over to the new object */ - for (i = 0; i < str_len; i++) - new_string->str[i] = str[i]; - } - - return new_string; -} - -/* - * Function: priv_tramp_string_find - * Description: Walk the trampoline string list and find a match for the - * provided string. If not match is found, NULL is returned. - */ -static struct tramp_string *priv_tramp_string_find(struct dload_state *dlthis, - char *str) -{ - struct tramp_string *cur_str = NULL; - struct tramp_string *ret_val = NULL; - u32 i; - u32 str_len = strlen(str); - - for (cur_str = dlthis->tramp.string_head; - (ret_val == NULL) && (cur_str != NULL); cur_str = cur_str->next) { - /* If the string lengths aren't equal, don't bother - * comparing */ - if (str_len != strlen(cur_str->str)) - continue; - - /* Walk the strings until one of them ends */ - for (i = 0; i < str_len; i++) { - /* If they don't match in the current position then - * break out now, no sense in continuing to look at - * this string. */ - if (str[i] != cur_str->str[i]) - break; - } - - if (i == str_len) - ret_val = cur_str; - } - - return ret_val; -} - -/* - * Function: priv_string_tbl_finalize - * Description: Flatten the trampoline string list into a table of NULL - * terminated strings. This is the same format of string table - * as used by the COFF/DOFF file. - */ -static int priv_string_tbl_finalize(struct dload_state *dlthis) -{ - int ret_val = 0; - struct tramp_string *cur_string; - char *cur_loc; - char *tmp; - - /* Allocate enough space for all strings that have been created. The - * table is simply all strings concatenated together will NULL - * endings. */ - dlthis->tramp.final_string_table = - (char *)dlthis->mysym->dload_allocate(dlthis->mysym, - dlthis->tramp. - tramp_string_size); - if (dlthis->tramp.final_string_table != NULL) { - /* We got our buffer, walk the list and release the nodes as* - * we go */ - cur_loc = dlthis->tramp.final_string_table; - cur_string = dlthis->tramp.string_head; - while (cur_string != NULL) { - /* Move the head/tail pointers */ - dlthis->tramp.string_head = cur_string->next; - if (dlthis->tramp.string_tail == cur_string) - dlthis->tramp.string_tail = NULL; - - /* Copy the string contents */ - for (tmp = cur_string->str; - *tmp != '\0'; tmp++, cur_loc++) - *cur_loc = *tmp; - - /* Pick up the NULL termination since it was missed by - * breaking using it to end the above loop. */ - *cur_loc = '\0'; - cur_loc++; - - /* Free the string node, we don't need it any more. */ - dlthis->mysym->dload_deallocate(dlthis->mysym, - cur_string); - - /* Move our pointer to the next one */ - cur_string = dlthis->tramp.string_head; - } - - /* Update our return value to success */ - ret_val = 1; - } else - dload_error(dlthis, "Failed to allocate trampoline " - "string table"); - - return ret_val; -} - -/* - * Function: priv_tramp_sect_alloc - * Description: Virtually allocate space from the trampoline section. This - * function returns the next offset within the trampoline section - * that is available and moved the next available offset by the - * requested size. NO TARGET ALLOCATION IS DONE AT THIS TIME. - */ -static u32 priv_tramp_sect_alloc(struct dload_state *dlthis, u32 tramp_size) -{ - u32 ret_val; - - /* If the next available address is 0, this is our first allocation. - * Create a section name string to go into the string table . */ - if (dlthis->tramp.tramp_sect_next_addr == 0) { - dload_syms_error(dlthis->mysym, "*** WARNING *** created " - "dynamic TRAMPOLINE section for module %s", - dlthis->str_head); - } - - /* Reserve space for the new trampoline */ - ret_val = dlthis->tramp.tramp_sect_next_addr; - dlthis->tramp.tramp_sect_next_addr += tramp_size; - return ret_val; -} - -/* - * Function: priv_tramp_sym_create - * Description: Allocate and create a new trampoline specific symbol and add - * it to the trampoline symbol list. These symbols will include - * trampoline points as well as the external symbols they - * reference. - */ -static struct tramp_sym *priv_tramp_sym_create(struct dload_state *dlthis, - u32 str_index, - struct local_symbol *tmp_sym) -{ - struct tramp_sym *new_sym = NULL; - u32 i; - - /* Allocate new space for the symbol in the symbol table. */ - new_sym = - (struct tramp_sym *)dlthis->mysym->dload_allocate(dlthis->mysym, - sizeof(struct tramp_sym)); - if (new_sym != NULL) { - for (i = 0; i != sizeof(struct tramp_sym); i++) - *((char *)new_sym + i) = 0; - - /* Assign this symbol the next symbol index for easier - * reference later during relocation. */ - new_sym->index = dlthis->tramp.tramp_sym_next_index; - dlthis->tramp.tramp_sym_next_index++; - - /* Populate the symbol information. At this point any - * trampoline symbols will be the offset location, not the - * final. Copy over the symbol info to start, then be sure to - * get the string index from the trampoline string table. */ - new_sym->sym_info = *tmp_sym; - new_sym->str_index = str_index; - - /* Push the new symbol to the tail of the symbol table list */ - new_sym->next = NULL; - if (dlthis->tramp.symbol_head == NULL) - dlthis->tramp.symbol_head = new_sym; - else - dlthis->tramp.symbol_tail->next = new_sym; - - dlthis->tramp.symbol_tail = new_sym; - } - - return new_sym; -} - -/* - * Function: priv_tramp_sym_get - * Description: Search for the symbol with the matching string index (from - * the trampoline string table) and return the trampoline - * symbol object, if found. Otherwise return NULL. - */ -static struct tramp_sym *priv_tramp_sym_get(struct dload_state *dlthis, - u32 string_index) -{ - struct tramp_sym *sym_found = NULL; - - /* Walk the symbol table list and search vs. the string index */ - for (sym_found = dlthis->tramp.symbol_head; - sym_found != NULL; sym_found = sym_found->next) { - if (sym_found->str_index == string_index) - break; - } - - return sym_found; -} - -/* - * Function: priv_tramp_sym_find - * Description: Search for a trampoline symbol based on the string name of - * the symbol. Return the symbol object, if found, otherwise - * return NULL. - */ -static struct tramp_sym *priv_tramp_sym_find(struct dload_state *dlthis, - char *string) -{ - struct tramp_sym *sym_found = NULL; - struct tramp_string *str_found = NULL; - - /* First, search for the string, then search for the sym based on the - string index. */ - str_found = priv_tramp_string_find(dlthis, string); - if (str_found != NULL) - sym_found = priv_tramp_sym_get(dlthis, str_found->index); - - return sym_found; -} - -/* - * Function: priv_tramp_sym_finalize - * Description: Allocate a flat symbol table for the trampoline section, - * put each trampoline symbol into the table, adjust the - * symbol value based on the section address on the target and - * free the trampoline symbol list nodes. - */ -static int priv_tramp_sym_finalize(struct dload_state *dlthis) -{ - int ret_val = 0; - struct tramp_sym *cur_sym; - struct ldr_section_info *tramp_sect = - &dlthis->ldr_sections[dlthis->allocated_secn_count]; - struct local_symbol *new_sym; - - /* Allocate a table to hold a flattened version of all symbols - * created. */ - dlthis->tramp.final_sym_table = - (struct local_symbol *)dlthis->mysym->dload_allocate(dlthis->mysym, - (sizeof(struct local_symbol) * dlthis->tramp. - tramp_sym_next_index)); - if (dlthis->tramp.final_sym_table != NULL) { - /* Walk the list of all symbols, copy it over to the flattened - * table. After it has been copied, the node can be freed as - * it is no longer needed. */ - new_sym = dlthis->tramp.final_sym_table; - cur_sym = dlthis->tramp.symbol_head; - while (cur_sym != NULL) { - /* Pop it off the list */ - dlthis->tramp.symbol_head = cur_sym->next; - if (cur_sym == dlthis->tramp.symbol_tail) - dlthis->tramp.symbol_tail = NULL; - - /* Copy the symbol contents into the flat table */ - *new_sym = cur_sym->sym_info; - - /* Now finalize the symbol. If it is in the tramp - * section, we need to adjust for the section start. - * If it is external then we don't need to adjust at - * all. - * NOTE: THIS CODE ASSUMES THAT THE TRAMPOLINE IS - * REFERENCED LIKE A CALL TO AN EXTERNAL SO VALUE AND - * DELTA ARE THE SAME. SEE THE FUNCTION dload_symbols - * WHERE DN_UNDEF IS HANDLED FOR MORE REFERENCE. */ - if (new_sym->secnn < 0) { - new_sym->value += tramp_sect->load_addr; - new_sym->delta = new_sym->value; - } - - /* Let go of the symbol node */ - dlthis->mysym->dload_deallocate(dlthis->mysym, cur_sym); - - /* Move to the next node */ - cur_sym = dlthis->tramp.symbol_head; - new_sym++; - } - - ret_val = 1; - } else - dload_error(dlthis, "Failed to alloc trampoline sym table"); - - return ret_val; -} - -/* - * Function: priv_tgt_img_gen - * Description: Allocate storage for and copy the target specific image data - * and fix up its relocations for the new external symbol. If - * a trampoline image packet was successfully created it is added - * to the trampoline list. - */ -static int priv_tgt_img_gen(struct dload_state *dlthis, u32 base, - u32 gen_index, struct tramp_sym *new_ext_sym) -{ - struct tramp_img_pkt *new_img_pkt = NULL; - u32 i; - u32 pkt_size = tramp_img_pkt_size_get(); - u8 *gen_tbl_entry; - u8 *pkt_data; - struct reloc_record_t *cur_relo; - int ret_val = 0; - - /* Allocate a new image packet and set it up. */ - new_img_pkt = - (struct tramp_img_pkt *)dlthis->mysym->dload_allocate(dlthis->mysym, - pkt_size); - if (new_img_pkt != NULL) { - /* Save the base, this is where it goes in the section */ - new_img_pkt->base = base; - - /* Copy over the image data and relos from the target table */ - pkt_data = (u8 *) &new_img_pkt->hdr; - gen_tbl_entry = (u8 *) &tramp_gen_info[gen_index]; - for (i = 0; i < pkt_size; i++) { - *pkt_data = *gen_tbl_entry; - pkt_data++; - gen_tbl_entry++; - } - - /* Update the relocations to point to the external symbol */ - cur_relo = - (struct reloc_record_t *)((u8 *) &new_img_pkt->hdr + - new_img_pkt->hdr.relo_offset); - for (i = 0; i < new_img_pkt->hdr.num_relos; i++) - cur_relo[i].SYMNDX = new_ext_sym->index; - - /* Add it to the trampoline list. */ - new_img_pkt->next = dlthis->tramp.tramp_pkts; - dlthis->tramp.tramp_pkts = new_img_pkt; - - ret_val = 1; - } - - return ret_val; -} - -/* - * Function: priv_pkt_relo - * Description: Take the provided image data and the collection of relocations - * for it and perform the relocations. Note that all relocations - * at this stage are considered SECOND PASS since the original - * image has already been processed in the first pass. This means - * TRAMPOLINES ARE TREATED AS 2ND PASS even though this is really - * the first (and only) relocation that will be performed on them. - */ -static int priv_pkt_relo(struct dload_state *dlthis, tgt_au_t *data, - struct reloc_record_t *rp[], u32 relo_count) -{ - int ret_val = 1; - u32 i; - bool tmp; - - /* Walk through all of the relos and process them. This function is - * the equivalent of relocate_packet() from cload.c, but specialized - * for trampolines and 2nd phase relocations. */ - for (i = 0; i < relo_count; i++) - dload_relocate(dlthis, data, rp[i], &tmp, true); - - return ret_val; -} - -/* - * Function: priv_tramp_pkt_finalize - * Description: Walk the list of all trampoline packets and finalize them. - * Each trampoline image packet will be relocated now that the - * trampoline section has been allocated on the target. Once - * all of the relocations are done the trampoline image data - * is written into target memory and the trampoline packet - * is freed: it is no longer needed after this point. - */ -static int priv_tramp_pkt_finalize(struct dload_state *dlthis) -{ - int ret_val = 1; - struct tramp_img_pkt *cur_pkt = NULL; - struct reloc_record_t *relos[MAX_RELOS_PER_PASS]; - u32 relos_done; - u32 i; - struct reloc_record_t *cur_relo; - struct ldr_section_info *sect_info = - &dlthis->ldr_sections[dlthis->allocated_secn_count]; - - /* Walk the list of trampoline packets and relocate each packet. This - * function is the trampoline equivalent of dload_data() from - * cload.c. */ - cur_pkt = dlthis->tramp.tramp_pkts; - while ((ret_val != 0) && (cur_pkt != NULL)) { - /* Remove the pkt from the list */ - dlthis->tramp.tramp_pkts = cur_pkt->next; - - /* Setup section and image offset information for the relo */ - dlthis->image_secn = sect_info; - dlthis->image_offset = cur_pkt->base; - dlthis->delta_runaddr = sect_info->run_addr; - - /* Walk through all relos for the packet */ - relos_done = 0; - cur_relo = (struct reloc_record_t *)((u8 *) &cur_pkt->hdr + - cur_pkt->hdr.relo_offset); - while (relos_done < cur_pkt->hdr.num_relos) { -#ifdef ENABLE_TRAMP_DEBUG - dload_syms_error(dlthis->mysym, - "===> Trampoline %x branches to %x", - sect_info->run_addr + - dlthis->image_offset, - dlthis-> - tramp.final_sym_table[cur_relo-> - SYMNDX].value); -#endif - - for (i = 0; - ((i < MAX_RELOS_PER_PASS) && - ((i + relos_done) < cur_pkt->hdr.num_relos)); i++) - relos[i] = cur_relo + i; - - /* Do the actual relo */ - ret_val = priv_pkt_relo(dlthis, - (tgt_au_t *) &cur_pkt->payload, - relos, i); - if (ret_val == 0) { - dload_error(dlthis, - "Relocation of trampoline pkt at %x" - " failed", cur_pkt->base + - sect_info->run_addr); - break; - } - - relos_done += i; - cur_relo += i; - } - - /* Make sure we didn't hit a problem */ - if (ret_val != 0) { - /* Relos are done for the packet, write it to the - * target */ - ret_val = dlthis->myio->writemem(dlthis->myio, - &cur_pkt->payload, - sect_info->load_addr + - cur_pkt->base, - sect_info, - BYTE_TO_HOST - (cur_pkt->hdr. - tramp_code_size)); - if (ret_val == 0) { - dload_error(dlthis, - "Write to " FMT_UI32 " failed", - sect_info->load_addr + - cur_pkt->base); - } - - /* Done with the pkt, let it go */ - dlthis->mysym->dload_deallocate(dlthis->mysym, cur_pkt); - - /* Get the next packet to process */ - cur_pkt = dlthis->tramp.tramp_pkts; - } - } - - return ret_val; -} - -/* - * Function: priv_dup_pkt_finalize - * Description: Walk the list of duplicate image packets and finalize them. - * Each duplicate packet will be relocated again for the - * relocations that previously failed and have been adjusted - * to point at a trampoline. Once all relocations for a packet - * have been done, write the packet into target memory. The - * duplicate packet and its relocation chain are all freed - * after use here as they are no longer needed after this. - */ -static int priv_dup_pkt_finalize(struct dload_state *dlthis) -{ - int ret_val = 1; - struct tramp_img_dup_pkt *cur_pkt; - struct tramp_img_dup_relo *cur_relo; - struct reloc_record_t *relos[MAX_RELOS_PER_PASS]; - struct doff_scnhdr_t *sect_hdr = NULL; - s32 i; - - /* Similar to the trampoline pkt finalize, this function walks each dup - * pkt that was generated and performs all relocations that were - * deferred to a 2nd pass. This is the equivalent of dload_data() from - * cload.c, but does not need the additional reorder and checksum - * processing as it has already been done. */ - cur_pkt = dlthis->tramp.dup_pkts; - while ((ret_val != 0) && (cur_pkt != NULL)) { - /* Remove the node from the list, we'll be freeing it - * shortly */ - dlthis->tramp.dup_pkts = cur_pkt->next; - - /* Setup the section and image offset for relocation */ - dlthis->image_secn = &dlthis->ldr_sections[cur_pkt->secnn]; - dlthis->image_offset = cur_pkt->offset; - - /* In order to get the delta run address, we need to reference - * the original section header. It's a bit ugly, but needed - * for relo. */ - i = (s32) (dlthis->image_secn - dlthis->ldr_sections); - sect_hdr = dlthis->sect_hdrs + i; - dlthis->delta_runaddr = sect_hdr->ds_paddr; - - /* Walk all relos in the chain and process each. */ - cur_relo = cur_pkt->relo_chain; - while (cur_relo != NULL) { - /* Process them a chunk at a time to be efficient */ - for (i = 0; (i < MAX_RELOS_PER_PASS) - && (cur_relo != NULL); - i++, cur_relo = cur_relo->next) { - relos[i] = &cur_relo->relo; - cur_pkt->relo_chain = cur_relo->next; - } - - /* Do the actual relo */ - ret_val = priv_pkt_relo(dlthis, - cur_pkt->img_pkt.img_data, - relos, i); - if (ret_val == 0) { - dload_error(dlthis, - "Relocation of dup pkt at %x" - " failed", cur_pkt->offset + - dlthis->image_secn->run_addr); - break; - } - - /* Release all of these relos, we're done with them */ - while (i > 0) { - dlthis->mysym->dload_deallocate(dlthis->mysym, - GET_CONTAINER - (relos[i - 1], - struct tramp_img_dup_relo, - relo)); - i--; - } - - /* DO NOT ADVANCE cur_relo, IT IS ALREADY READY TO - * GO! */ - } - - /* Done with all relos. Make sure we didn't have a problem and - * write it out to the target */ - if (ret_val != 0) { - ret_val = dlthis->myio->writemem(dlthis->myio, - cur_pkt->img_pkt. - img_data, - dlthis->image_secn-> - load_addr + - cur_pkt->offset, - dlthis->image_secn, - BYTE_TO_HOST - (cur_pkt->img_pkt. - packet_size)); - if (ret_val == 0) { - dload_error(dlthis, - "Write to " FMT_UI32 " failed", - dlthis->image_secn->load_addr + - cur_pkt->offset); - } - - dlthis->mysym->dload_deallocate(dlthis->mysym, cur_pkt); - - /* Advance to the next packet */ - cur_pkt = dlthis->tramp.dup_pkts; - } - } - - return ret_val; -} - -/* - * Function: priv_dup_find - * Description: Walk the list of existing duplicate packets and find a - * match based on the section number and image offset. Return - * the duplicate packet if found, otherwise NULL. - */ -static struct tramp_img_dup_pkt *priv_dup_find(struct dload_state *dlthis, - s16 secnn, u32 image_offset) -{ - struct tramp_img_dup_pkt *cur_pkt = NULL; - - for (cur_pkt = dlthis->tramp.dup_pkts; - cur_pkt != NULL; cur_pkt = cur_pkt->next) { - if ((cur_pkt->secnn == secnn) && - (cur_pkt->offset == image_offset)) { - /* Found a match, break out */ - break; - } - } - - return cur_pkt; -} - -/* - * Function: priv_img_pkt_dup - * Description: Duplicate the original image packet. If this is the first - * time this image packet has been seen (based on section number - * and image offset), create a new duplicate packet and add it - * to the dup packet list. If not, just get the existing one and - * update it with the current packet contents (since relocation - * on the packet is still ongoing in first pass.) Create a - * duplicate of the provided relocation, but update it to point - * to the new trampoline symbol. Add the new relocation dup to - * the dup packet's relo chain for 2nd pass relocation later. - */ -static int priv_img_pkt_dup(struct dload_state *dlthis, - s16 secnn, u32 image_offset, - struct image_packet_t *ipacket, - struct reloc_record_t *rp, - struct tramp_sym *new_tramp_sym) -{ - struct tramp_img_dup_pkt *dup_pkt = NULL; - u32 new_dup_size; - s32 i; - int ret_val = 0; - struct tramp_img_dup_relo *dup_relo = NULL; - - /* Determine if this image packet is already being tracked in the - dup list for other trampolines. */ - dup_pkt = priv_dup_find(dlthis, secnn, image_offset); - - if (dup_pkt == NULL) { - /* This image packet does not exist in our tracking, so create - * a new one and add it to the head of the list. */ - new_dup_size = sizeof(struct tramp_img_dup_pkt) + - ipacket->packet_size; - - dup_pkt = (struct tramp_img_dup_pkt *) - dlthis->mysym->dload_allocate(dlthis->mysym, new_dup_size); - if (dup_pkt != NULL) { - /* Save off the section and offset information */ - dup_pkt->secnn = secnn; - dup_pkt->offset = image_offset; - dup_pkt->relo_chain = NULL; - - /* Copy the original packet content */ - dup_pkt->img_pkt = *ipacket; - dup_pkt->img_pkt.img_data = (u8 *) (dup_pkt + 1); - for (i = 0; i < ipacket->packet_size; i++) - *(dup_pkt->img_pkt.img_data + i) = - *(ipacket->img_data + i); - - /* Add the packet to the dup list */ - dup_pkt->next = dlthis->tramp.dup_pkts; - dlthis->tramp.dup_pkts = dup_pkt; - } else - dload_error(dlthis, "Failed to create dup packet!"); - } else { - /* The image packet contents could have changed since - * trampoline detection happens during relocation of the image - * packets. So, we need to update the image packet contents - * before adding relo information. */ - for (i = 0; i < dup_pkt->img_pkt.packet_size; i++) - *(dup_pkt->img_pkt.img_data + i) = - *(ipacket->img_data + i); - } - - /* Since the previous code may have allocated a new dup packet for us, - double check that we actually have one. */ - if (dup_pkt != NULL) { - /* Allocate a new node for the relo chain. Each image packet - * can potentially have multiple relocations that cause a - * trampoline to be generated. So, we keep them in a chain, - * order is not important. */ - dup_relo = dlthis->mysym->dload_allocate(dlthis->mysym, - sizeof(struct tramp_img_dup_relo)); - if (dup_relo != NULL) { - /* Copy the relo contents, adjust for the new - * trampoline and add it to the list. */ - dup_relo->relo = *rp; - dup_relo->relo.SYMNDX = new_tramp_sym->index; - - dup_relo->next = dup_pkt->relo_chain; - dup_pkt->relo_chain = dup_relo; - - /* That's it, we're done. Make sure we update our - * return value to be success since everything finished - * ok */ - ret_val = 1; - } else - dload_error(dlthis, "Unable to alloc dup relo"); - } - - return ret_val; -} - -/* - * Function: dload_tramp_avail - * Description: Check to see if the target supports a trampoline for this type - * of relocation. Return true if it does, otherwise false. - */ -bool dload_tramp_avail(struct dload_state *dlthis, struct reloc_record_t *rp) -{ - bool ret_val = false; - u16 map_index; - u16 gen_index; - - /* Check type hash vs. target tramp table */ - map_index = HASH_FUNC(rp->TYPE); - gen_index = tramp_map[map_index]; - if (gen_index != TRAMP_NO_GEN_AVAIL) - ret_val = true; - - return ret_val; -} - -/* - * Function: dload_tramp_generate - * Description: Create a new trampoline for the provided image packet and - * relocation causing problems. This will create the trampoline - * as well as duplicate/update the image packet and relocation - * causing the problem, which will be relo'd again during - * finalization. - */ -int dload_tramp_generate(struct dload_state *dlthis, s16 secnn, - u32 image_offset, struct image_packet_t *ipacket, - struct reloc_record_t *rp) -{ - u16 map_index; - u16 gen_index; - int ret_val = 1; - char tramp_sym_str[TRAMP_SYM_PREFIX_LEN + TRAMP_SYM_HEX_ASCII_LEN]; - struct local_symbol *ref_sym; - struct tramp_sym *new_tramp_sym; - struct tramp_sym *new_ext_sym; - struct tramp_string *new_tramp_str; - u32 new_tramp_base; - struct local_symbol tmp_sym; - struct local_symbol ext_tmp_sym; - - /* Hash the relo type to get our generator information */ - map_index = HASH_FUNC(rp->TYPE); - gen_index = tramp_map[map_index]; - if (gen_index != TRAMP_NO_GEN_AVAIL) { - /* If this is the first trampoline, create the section name in - * our string table for debug help later. */ - if (dlthis->tramp.string_head == NULL) { - priv_tramp_string_create(dlthis, - strlen(TRAMP_SECT_NAME), - TRAMP_SECT_NAME); - } -#ifdef ENABLE_TRAMP_DEBUG - dload_syms_error(dlthis->mysym, - "Trampoline at img loc %x, references %x", - dlthis->ldr_sections[secnn].run_addr + - image_offset + rp->vaddr, - dlthis->local_symtab[rp->SYMNDX].value); -#endif - - /* Generate the trampoline string, check if already defined. - * If the relo symbol index is -1, it means we need the section - * info for relo later. To do this we'll dummy up a symbol - * with the section delta and run addresses. */ - if (rp->SYMNDX == -1) { - ext_tmp_sym.value = - dlthis->ldr_sections[secnn].run_addr; - ext_tmp_sym.delta = dlthis->sect_hdrs[secnn].ds_paddr; - ref_sym = &ext_tmp_sym; - } else - ref_sym = &(dlthis->local_symtab[rp->SYMNDX]); - - priv_tramp_sym_gen_name(ref_sym->value, tramp_sym_str); - new_tramp_sym = priv_tramp_sym_find(dlthis, tramp_sym_str); - if (new_tramp_sym == NULL) { - /* If tramp string not defined, create it and a new - * string, and symbol for it as well as the original - * symbol which caused the trampoline. */ - new_tramp_str = priv_tramp_string_create(dlthis, - strlen - (tramp_sym_str), - tramp_sym_str); - if (new_tramp_str == NULL) { - dload_error(dlthis, "Failed to create new " - "trampoline string\n"); - ret_val = 0; - } else { - /* Allocate tramp section space for the new - * tramp from the target */ - new_tramp_base = priv_tramp_sect_alloc(dlthis, - tramp_size_get()); - - /* We have a string, create the new symbol and - * duplicate the external. */ - tmp_sym.value = new_tramp_base; - tmp_sym.delta = 0; - tmp_sym.secnn = -1; - tmp_sym.sclass = 0; - new_tramp_sym = priv_tramp_sym_create(dlthis, - new_tramp_str-> - index, - &tmp_sym); - - new_ext_sym = priv_tramp_sym_create(dlthis, -1, - ref_sym); - - if ((new_tramp_sym != NULL) && - (new_ext_sym != NULL)) { - /* Call the image generator to get the - * new image data and fix up its - * relocations for the external - * symbol. */ - ret_val = priv_tgt_img_gen(dlthis, - new_tramp_base, - gen_index, - new_ext_sym); - - /* Add generated image data to tramp - * image list */ - if (ret_val != 1) { - dload_error(dlthis, "Failed to " - "create img pkt for" - " trampoline\n"); - } - } else { - dload_error(dlthis, "Failed to create " - "new tramp syms " - "(%8.8X, %8.8X)\n", - new_tramp_sym, new_ext_sym); - ret_val = 0; - } - } - } - - /* Duplicate the image data and relo record that caused the - * tramp, including update the relo data to point to the tramp - * symbol. */ - if (ret_val == 1) { - ret_val = priv_img_pkt_dup(dlthis, secnn, image_offset, - ipacket, rp, new_tramp_sym); - if (ret_val != 1) { - dload_error(dlthis, "Failed to create dup of " - "original img pkt\n"); - } - } - } - - return ret_val; -} - -/* - * Function: dload_tramp_pkt_update - * Description: Update the duplicate copy of this image packet, which the - * trampoline layer is already tracking. This call is critical - * to make if trampolines were generated anywhere within the - * packet and first pass relo continued on the remainder. The - * trampoline layer needs the updates image data so when 2nd - * pass relo is done during finalize the image packet can be - * written to the target since all relo is done. - */ -int dload_tramp_pkt_udpate(struct dload_state *dlthis, s16 secnn, - u32 image_offset, struct image_packet_t *ipacket) -{ - struct tramp_img_dup_pkt *dup_pkt = NULL; - s32 i; - int ret_val = 0; - - /* Find the image packet in question, the caller needs us to update it - since a trampoline was previously generated. */ - dup_pkt = priv_dup_find(dlthis, secnn, image_offset); - if (dup_pkt != NULL) { - for (i = 0; i < dup_pkt->img_pkt.packet_size; i++) - *(dup_pkt->img_pkt.img_data + i) = - *(ipacket->img_data + i); - - ret_val = 1; - } else { - dload_error(dlthis, - "Unable to find existing DUP pkt for %x, offset %x", - secnn, image_offset); - - } - - return ret_val; -} - -/* - * Function: dload_tramp_finalize - * Description: If any trampolines were created, finalize everything on the - * target by allocating the trampoline section on the target, - * finalizing the trampoline symbols, finalizing the trampoline - * packets (write the new section to target memory) and finalize - * the duplicate packets by doing 2nd pass relo over them. - */ -int dload_tramp_finalize(struct dload_state *dlthis) -{ - int ret_val = 1; - - if (dlthis->tramp.tramp_sect_next_addr != 0) { - /* Finalize strings into a flat table. This is needed so it - * can be added to the debug string table later. */ - ret_val = priv_string_tbl_finalize(dlthis); - - /* Do target allocation for section BEFORE finalizing - * symbols. */ - if (ret_val != 0) - ret_val = priv_tramp_sect_tgt_alloc(dlthis); - - /* Finalize symbols with their correct target information and - * flatten */ - if (ret_val != 0) - ret_val = priv_tramp_sym_finalize(dlthis); - - /* Finalize all trampoline packets. This performs the - * relocation on the packets as well as writing them to target - * memory. */ - if (ret_val != 0) - ret_val = priv_tramp_pkt_finalize(dlthis); - - /* Perform a 2nd pass relocation on the dup list. */ - if (ret_val != 0) - ret_val = priv_dup_pkt_finalize(dlthis); - } - - return ret_val; -} - -/* - * Function: dload_tramp_cleanup - * Description: Release all temporary resources used in the trampoline layer. - * Note that the target memory which may have been allocated and - * written to store the trampolines is NOT RELEASED HERE since it - * is potentially still in use. It is automatically released - * when the module is unloaded. - */ -void dload_tramp_cleanup(struct dload_state *dlthis) -{ - struct tramp_info *tramp = &dlthis->tramp; - struct tramp_sym *cur_sym; - struct tramp_string *cur_string; - struct tramp_img_pkt *cur_tramp_pkt; - struct tramp_img_dup_pkt *cur_dup_pkt; - struct tramp_img_dup_relo *cur_dup_relo; - - /* If there were no tramps generated, just return */ - if (tramp->tramp_sect_next_addr == 0) - return; - - /* Destroy all tramp information */ - for (cur_sym = tramp->symbol_head; - cur_sym != NULL; cur_sym = tramp->symbol_head) { - tramp->symbol_head = cur_sym->next; - if (tramp->symbol_tail == cur_sym) - tramp->symbol_tail = NULL; - - dlthis->mysym->dload_deallocate(dlthis->mysym, cur_sym); - } - - if (tramp->final_sym_table != NULL) - dlthis->mysym->dload_deallocate(dlthis->mysym, - tramp->final_sym_table); - - for (cur_string = tramp->string_head; - cur_string != NULL; cur_string = tramp->string_head) { - tramp->string_head = cur_string->next; - if (tramp->string_tail == cur_string) - tramp->string_tail = NULL; - - dlthis->mysym->dload_deallocate(dlthis->mysym, cur_string); - } - - if (tramp->final_string_table != NULL) - dlthis->mysym->dload_deallocate(dlthis->mysym, - tramp->final_string_table); - - for (cur_tramp_pkt = tramp->tramp_pkts; - cur_tramp_pkt != NULL; cur_tramp_pkt = tramp->tramp_pkts) { - tramp->tramp_pkts = cur_tramp_pkt->next; - dlthis->mysym->dload_deallocate(dlthis->mysym, cur_tramp_pkt); - } - - for (cur_dup_pkt = tramp->dup_pkts; - cur_dup_pkt != NULL; cur_dup_pkt = tramp->dup_pkts) { - tramp->dup_pkts = cur_dup_pkt->next; - - for (cur_dup_relo = cur_dup_pkt->relo_chain; - cur_dup_relo != NULL; - cur_dup_relo = cur_dup_pkt->relo_chain) { - cur_dup_pkt->relo_chain = cur_dup_relo->next; - dlthis->mysym->dload_deallocate(dlthis->mysym, - cur_dup_relo); - } - - dlthis->mysym->dload_deallocate(dlthis->mysym, cur_dup_pkt); - } -} |