Whitebox
/
u-boot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

common: cmd_elf.c: fix checkpath.pl warnings

Browse Source 
[Tom: Move valid_elf_image around and don't mark it as static as another
board makes use of this function]

Signed-off-by: Daniel Schwierzeck <daniel.schwierzeck@gmail.com>
Signed-off-by: Tom Rini <trini@ti.com>
master
Daniel Schwierzeck 13 years ago committed by Tom Rini
parent 7b64f66c58
commit 62e03d33c9
1 changed files with 94 additions and 95 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 189
      common/cmd_elf.c

189
common/cmd_elf.c
Unescape View File

@ -24,13 +24,12 @@
DECLARE_GLOBAL_DATA_PTR;
#endif
int valid_elf_image (unsigned long addr);
static unsigned long load_elf_image_phdr(unsigned long addr);
static unsigned long load_elf_image_shdr(unsigned long addr);
/* Allow ports to override the default behavior */
__attribute__((weak))
unsigned long do_bootelf_exec (ulong (*entry)(int, char * const[]),
unsigned long do_bootelf_exec(ulong (*entry)(int, char * const[]),
int argc, char * const argv[])
{
unsigned long ret;
@ -39,26 +38,59 @@ unsigned long do_bootelf_exec (ulong (*entry)(int, char * const[]),
* QNX images require the data cache is disabled.
* Data cache is already flushed, so just turn it off.
*/
int dcache = dcache_status ();
int dcache = dcache_status();
if (dcache)
dcache_disable ();
dcache_disable();
/*
* pass address parameter as argv[0] (aka command name),
* and all remaining args
*/
ret = entry (argc, argv);
ret = entry(argc, argv);
if (dcache)
dcache_enable ();
dcache_enable();
return ret;
}
/* ======================================================================
* Determine if a valid ELF image exists at the given memory location.
* First looks at the ELF header magic field, the makes sure that it is
* executable and makes sure that it is for a PowerPC.
* ====================================================================== */
int valid_elf_image(unsigned long addr)
{
Elf32_Ehdr *ehdr; /* Elf header structure pointer */
/* -------------------------------------------------- */
ehdr = (Elf32_Ehdr *) addr;
if (!IS_ELF(*ehdr)) {
printf("## No elf image at address 0x%08lx\n", addr);
return 0;
}
if (ehdr->e_type != ET_EXEC) {
printf("## Not a 32-bit elf image at address 0x%08lx\n", addr);
return 0;
}
#if 0
if (ehdr->e_machine != EM_PPC) {
printf("## Not a PowerPC elf image at address 0x%08lx\n", addr);
return 0;
}
#endif
return 1;
}
/* ======================================================================
* Interpreter command to boot an arbitrary ELF image from memory.
* ====================================================================== */
int do_bootelf (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
int do_bootelf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
unsigned long addr; /* Address of the ELF image */
unsigned long rc; /* Return value from user code */
@ -83,7 +115,7 @@ int do_bootelf (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
else
addr = load_addr;
if (!valid_elf_image (addr))
if (!valid_elf_image(addr))
return 1;
if (sload && sload[1] == 'p')
@ -91,17 +123,17 @@ int do_bootelf (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
else
addr = load_elf_image_shdr(addr);
printf ("## Starting application at 0x%08lx ...\n", addr);
printf("## Starting application at 0x%08lx ...\n", addr);
/*
* pass address parameter as argv[0] (aka command name),
* and all remaining args
*/
rc = do_bootelf_exec ((void *)addr, argc - 1, argv + 1);
rc = do_bootelf_exec((void *)addr, argc - 1, argv + 1);
if (rc != 0)
rcode = 1;
printf ("## Application terminated, rc = 0x%lx\n", rc);
printf("## Application terminated, rc = 0x%lx\n", rc);
return rcode;
}
@ -110,10 +142,10 @@ int do_bootelf (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
* be either an ELF image or a raw binary. Will attempt to setup the
* bootline and other parameters correctly.
* ====================================================================== */
int do_bootvx (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
unsigned long addr; /* Address of image */
unsigned long bootaddr; /* Address to put the bootline */
unsigned long bootaddr; /* Address to put the bootline */
char *bootline; /* Text of the bootline */
char *tmp; /* Temporary char pointer */
char build_buf[128]; /* Buffer for building the bootline */
@ -127,16 +159,17 @@ int do_bootvx (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
if (argc < 2)
addr = load_addr;
else
addr = simple_strtoul (argv[1], NULL, 16);
addr = simple_strtoul(argv[1], NULL, 16);
#if defined(CONFIG_CMD_NET)
/* Check to see if we need to tftp the image ourselves before starting */
if ((argc == 2) && (strcmp (argv[1], "tftp") == 0)) {
/*
* Check to see if we need to tftp the image ourselves before starting
*/
if ((argc == 2) && (strcmp(argv[1], "tftp") == 0)) {
if (NetLoop(TFTPGET) <= 0)
return 1;
printf("Automatic boot of VxWorks image at address 0x%08lx "
"...\n", addr);
printf("Automatic boot of VxWorks image at address 0x%08lx ...\n",
addr);
}
#endif
@ -155,7 +188,7 @@ int do_bootvx (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
eth_getenv_enetaddr("ethaddr", (uchar *)build_buf);
memcpy(tmp, build_buf, 6);
#else
puts ("## Ethernet MAC address not copied to NV RAM\n");
puts("## Ethernet MAC address not copied to NV RAM\n");
#endif
/*
@ -164,53 +197,52 @@ int do_bootvx (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
* PowerPC is LOCAL_MEM_LOCAL_ADRS + BOOT_LINE_OFFSET which
* defaults to 0x4200
*/
if ((tmp = getenv ("bootaddr")) == NULL)
tmp = getenv("bootaddr");
if (tmp)
bootaddr = CONFIG_SYS_VXWORKS_BOOT_ADDR;
else
bootaddr = simple_strtoul (tmp, NULL, 16);
bootaddr = simple_strtoul(tmp, NULL, 16);
/*
* Check to see if the bootline is defined in the 'bootargs'
* parameter. If it is not defined, we may be able to
* construct the info
*/
if ((bootline = getenv ("bootargs")) != NULL) {
memcpy ((void *) bootaddr, bootline,
max (strlen (bootline), 255));
flush_cache (bootaddr, max (strlen (bootline), 255));
bootline = getenv("bootargs");
if (bootline) {
memcpy((void *) bootaddr, bootline,
max(strlen(bootline), 255));
flush_cache(bootaddr, max(strlen(bootline), 255));
} else {
sprintf (build_buf, CONFIG_SYS_VXWORKS_BOOT_DEVICE);
if ((tmp = getenv ("bootfile")) != NULL) {
sprintf (&build_buf[strlen (build_buf)],
sprintf(build_buf, CONFIG_SYS_VXWORKS_BOOT_DEVICE);
tmp = getenv("bootfile");
if (tmp)
sprintf(&build_buf[strlen(build_buf)],
"%s:%s ", CONFIG_SYS_VXWORKS_SERVERNAME, tmp);
} else {
sprintf (&build_buf[strlen (build_buf)],
else
sprintf(&build_buf[strlen(build_buf)],
"%s:file ", CONFIG_SYS_VXWORKS_SERVERNAME);
}
if ((tmp = getenv ("ipaddr")) != NULL) {
sprintf (&build_buf[strlen (build_buf)], "e=%s ", tmp);
}
tmp = getenv("ipaddr");
if (tmp)
sprintf(&build_buf[strlen(build_buf)], "e=%s ", tmp);
if ((tmp = getenv ("serverip")) != NULL) {
sprintf (&build_buf[strlen (build_buf)], "h=%s ", tmp);
}
tmp = getenv("serverip");
if (tmp)
sprintf(&build_buf[strlen(build_buf)], "h=%s ", tmp);
tmp = getenv("hostname");
if (tmp)
sprintf(&build_buf[strlen(build_buf)], "tn=%s ", tmp);
if ((tmp = getenv ("hostname")) != NULL) {
sprintf (&build_buf[strlen (build_buf)], "tn=%s ", tmp);
}
#ifdef CONFIG_SYS_VXWORKS_ADD_PARAMS
sprintf (&build_buf[strlen (build_buf)],
sprintf(&build_buf[strlen(build_buf)],
CONFIG_SYS_VXWORKS_ADD_PARAMS);
#endif
memcpy ((void *) bootaddr, build_buf,
max (strlen (build_buf), 255));
flush_cache (bootaddr, max (strlen (build_buf), 255));
memcpy((void *) bootaddr, build_buf,
max(strlen(build_buf), 255));
flush_cache(bootaddr, max(strlen(build_buf), 255));
}
/*
@ -219,55 +251,21 @@ int do_bootvx (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
* binary image
*/
if (valid_elf_image (addr)) {
addr = load_elf_image_shdr (addr);
if (valid_elf_image(addr)) {
addr = load_elf_image_shdr(addr);
} else {
puts ("## Not an ELF image, assuming binary\n");
puts("## Not an ELF image, assuming binary\n");
/* leave addr as load_addr */
}
printf ("## Using bootline (@ 0x%lx): %s\n", bootaddr,
printf("## Using bootline (@ 0x%lx): %s\n", bootaddr,
(char *) bootaddr);
printf ("## Starting vxWorks at 0x%08lx ...\n", addr);
printf("## Starting vxWorks at 0x%08lx ...\n", addr);
dcache_disable();
((void (*)(int)) addr) (0);
puts ("## vxWorks terminated\n");
return 1;
}
/* ======================================================================
* Determine if a valid ELF image exists at the given memory location.
* First looks at the ELF header magic field, the makes sure that it is
* executable and makes sure that it is for a PowerPC.
* ====================================================================== */
int valid_elf_image (unsigned long addr)
{
Elf32_Ehdr *ehdr; /* Elf header structure pointer */
/* -------------------------------------------------- */
ehdr = (Elf32_Ehdr *) addr;
if (!IS_ELF (*ehdr)) {
printf ("## No elf image at address 0x%08lx\n", addr);
return 0;
}
if (ehdr->e_type != ET_EXEC) {
printf ("## Not a 32-bit elf image at address 0x%08lx\n", addr);
return 0;
}
#if 0
if (ehdr->e_machine != EM_PPC) {
printf ("## Not a PowerPC elf image at address 0x%08lx\n",
addr);
return 0;
}
#endif
puts("## vxWorks terminated\n");
return 1;
}
@ -293,7 +291,8 @@ static unsigned long load_elf_image_phdr(unsigned long addr)
if (phdr->p_filesz)
memcpy(dst, src, phdr->p_filesz);
if (phdr->p_filesz != phdr->p_memsz)
memset(dst + phdr->p_filesz, 0x00, phdr->p_memsz - phdr->p_filesz);
memset(dst + phdr->p_filesz, 0x00,
phdr->p_memsz - phdr->p_filesz);
flush_cache((unsigned long)dst, phdr->p_filesz);
++phdr;
}
@ -315,7 +314,7 @@ static unsigned long load_elf_image_shdr(unsigned long addr)
/* Find the section header string table for output info */
shdr = (Elf32_Shdr *) (addr + ehdr->e_shoff +
(ehdr->e_shstrndx * sizeof (Elf32_Shdr)));
(ehdr->e_shstrndx * sizeof(Elf32_Shdr)));
if (shdr->sh_type == SHT_STRTAB)
strtab = (unsigned char *) (addr + shdr->sh_offset);
@ -323,7 +322,7 @@ static unsigned long load_elf_image_shdr(unsigned long addr)
/* Load each appropriate section */
for (i = 0; i < ehdr->e_shnum; ++i) {
shdr = (Elf32_Shdr *) (addr + ehdr->e_shoff +
(i * sizeof (Elf32_Shdr)));
(i * sizeof(Elf32_Shdr)));
if (!(shdr->sh_flags & SHF_ALLOC)
|| shdr->sh_addr == 0 || shdr->sh_size == 0) {
@ -340,14 +339,14 @@ static unsigned long load_elf_image_shdr(unsigned long addr)
}
if (shdr->sh_type == SHT_NOBITS) {
memset ((void *)shdr->sh_addr, 0, shdr->sh_size);
memset((void *)shdr->sh_addr, 0, shdr->sh_size);
} else {
image = (unsigned char *) addr + shdr->sh_offset;
memcpy ((void *) shdr->sh_addr,
memcpy((void *) shdr->sh_addr,
(const void *) image,
shdr->sh_size);
}
flush_cache (shdr->sh_addr, shdr->sh_size);
flush_cache(shdr->sh_addr, shdr->sh_size);
}
return ehdr->e_entry;

Write Preview
Loading…
Cancel
Save