1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2010 by Thomas Martitz
*
* 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 (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
#include "system.h"
#include "file.h"
#include "debug.h"
#include "load_code.h"
#if (CONFIG_PLATFORM & PLATFORM_NATIVE)
/* load binary blob from disk to memory, returning a handle */
void * lc_open(const char *filename, unsigned char *buf, size_t buf_size)
{
int fd = open(filename, O_RDONLY);
ssize_t read_size;
struct lc_header hdr;
unsigned char *buf_end = buf+buf_size;
off_t copy_size;
if (fd < 0)
{
DEBUGF("Could not open file");
goto error;
}
#if NUM_CORES > 1
/* Make sure COP cache is flushed and invalidated before loading */
{
int my_core = switch_core(CURRENT_CORE ^ 1);
cpucache_commit_discard();
switch_core(my_core);
}
#endif
/* read the header to obtain the load address */
read_size = read(fd, &hdr, sizeof(hdr));
if (read_size < 0)
{
DEBUGF("Could not read from file");
goto error_fd;
}
/* hdr.end_addr points to the end of the bss section,
* but there might be idata/icode behind that so the bytes to copy
* can be larger */
copy_size = MAX(filesize(fd), hdr.end_addr - hdr.load_addr);
if (hdr.load_addr < buf || (hdr.load_addr+copy_size) > buf_end)
{
DEBUGF("Binary doesn't fit into memory");
goto error_fd;
}
/* go back to beginning to load the whole thing (incl. header) */
if (lseek(fd, 0, SEEK_SET) < 0)
{
DEBUGF("lseek failed");
goto error_fd;
}
/* the header has the addresses where the code is linked at */
read_size = read(fd, hdr.load_addr, copy_size);
close(fd);
if (read_size < 0)
{
DEBUGF("Could not read from file");
goto error;
}
/* commit dcache and discard icache */
cpucache_commit_discard();
/* return a pointer the header, reused by lc_get_header() */
return hdr.load_addr;
error_fd:
close(fd);
error:
return NULL;
}
#elif (CONFIG_PLATFORM & PLATFORM_HOSTED)
/* libdl wrappers */
#ifdef WIN32
/* win32 */
#include <windows.h>
#define dlopen(_x_, _y_) LoadLibraryW(_x_)
#define dlsym(_x_, _y_) (void *)GetProcAddress(_x_, _y_)
#define dlclose(_x_) FreeLibrary(_x_)
static inline char *_dlerror(void)
{
static char err_buf[64];
FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,
err_buf, sizeof(err_buf), NULL);
return err_buf;
}
#define dlerror _dlerror
#else
/* unix */
#include <dlfcn.h>
#endif
#include <stdio.h>
#include "rbpaths.h"
#include "general.h"
void * _lc_open(const _lc_open_char *filename, unsigned char *buf, size_t buf_size)
{
(void)buf;
(void)buf_size;
return dlopen(filename, RTLD_NOW);
}
void *lc_open_from_mem(void *addr, size_t blob_size)
{
int fd, i;
char temp_filename[MAX_PATH];
/* We have to create the dynamic link library file from ram so we
can simulate the codec loading. With voice and crossfade,
multiple codecs may be loaded at the same time, so we need
to find an unused filename */
for (i = 0; i < 10; i++)
{
#if (CONFIG_PLATFORM & PLATFORM_ANDROID)
/* we need that path fixed, since get_user_file_path()
* gives us the folder on the sdcard where we cannot load libraries
* from (no exec permissions)
*/
snprintf(temp_filename, sizeof(temp_filename),
"/data/data/org.rockbox/app_rockbox/libtemp_binary_%d.so", i);
#else
char name[MAX_PATH];
const char *_name = get_user_file_path(ROCKBOX_DIR, NEED_WRITE, name, sizeof(name));
snprintf(temp_filename, sizeof(temp_filename),
"%s/libtemp_binary_%d.dll", _name, i);
#endif
fd = open(temp_filename, O_WRONLY|O_CREAT|O_TRUNC, 0700);
if (fd >= 0)
break; /* Created a file ok */
}
if (fd < 0)
{
DEBUGF("open failed\n");
return NULL;
}
if (write(fd, addr, blob_size) < (ssize_t)blob_size)
{
DEBUGF("Write failed\n");
close(fd);
remove(temp_filename);
return NULL;
}
close(fd);
return lc_open(temp_filename, NULL, 0);
}
void *_lc_get_header(void *handle)
{
char *ret = dlsym(handle, "__header");
if (ret == NULL)
ret = dlsym(handle, "___header");
return ret;
}
void _lc_close(void *handle)
{
if (handle)
dlclose(handle);
}
const char *lc_last_error(void)
{
return dlerror();
}
#endif
|
