diff options
author | Thomas Martitz <kugel@rockbox.org> | 2010-08-26 23:20:02 +0000 |
---|---|---|
committer | Thomas Martitz <kugel@rockbox.org> | 2010-08-26 23:20:02 +0000 |
commit | 73f057be6fcb849d5379073267e21e9526576ccd (patch) | |
tree | b2b239517ba89f4e9969918642006a3d15faa062 /apps | |
parent | 55dc25fe7273bf9aa71cdaea9a68c39fa3a22f50 (diff) | |
download | rockbox-73f057be6fcb849d5379073267e21e9526576ccd.tar.gz rockbox-73f057be6fcb849d5379073267e21e9526576ccd.zip |
Introduce a small api for loading code (codecs,plugins) from disk/memory.
It's a used by codec/plugin loading and vastly reduces code duplication. It's also a step forward in getting rid of libuisimulator in the application ports.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@27900 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps')
-rw-r--r-- | apps/codecs.c | 101 | ||||
-rw-r--r-- | apps/plugin.c | 102 | ||||
-rw-r--r-- | apps/plugins/plugin_crt0.c | 6 |
3 files changed, 74 insertions, 135 deletions
diff --git a/apps/codecs.c b/apps/codecs.c index 9e77dd9099..b072c65f40 100644 --- a/apps/codecs.c +++ b/apps/codecs.c | |||
@@ -28,6 +28,7 @@ | |||
28 | #include <ctype.h> | 28 | #include <ctype.h> |
29 | #include <stdarg.h> | 29 | #include <stdarg.h> |
30 | #include "string-extra.h" | 30 | #include "string-extra.h" |
31 | #include "load_code.h" | ||
31 | #include "debug.h" | 32 | #include "debug.h" |
32 | #include "button.h" | 33 | #include "button.h" |
33 | #include "dir.h" | 34 | #include "dir.h" |
@@ -74,26 +75,13 @@ size_t codec_size; | |||
74 | 75 | ||
75 | extern void* plugin_get_audio_buffer(size_t *buffer_size); | 76 | extern void* plugin_get_audio_buffer(size_t *buffer_size); |
76 | 77 | ||
78 | #if (CONFIG_PLATFORM & PLATFORM_NATIVE) && defined(HAVE_RECORDING) | ||
77 | #undef open | 79 | #undef open |
78 | static int open(const char* pathname, int flags, ...) | 80 | static int open(const char* pathname, int flags, ...) |
79 | { | 81 | { |
80 | #if (CONFIG_PLATFORM & PLATFORM_HOSTED) | ||
81 | int fd; | ||
82 | if (flags & O_CREAT) | ||
83 | { | ||
84 | va_list ap; | ||
85 | va_start(ap, flags); | ||
86 | fd = sim_open(pathname, flags, va_arg(ap, unsigned int)); | ||
87 | va_end(ap); | ||
88 | } | ||
89 | else | ||
90 | fd = sim_open(pathname, flags); | ||
91 | |||
92 | return fd; | ||
93 | #else | ||
94 | return file_open(pathname, flags); | 82 | return file_open(pathname, flags); |
95 | #endif | ||
96 | } | 83 | } |
84 | #endif | ||
97 | struct codec_api ci = { | 85 | struct codec_api ci = { |
98 | 86 | ||
99 | 0, /* filesize */ | 87 | 0, /* filesize */ |
@@ -197,62 +185,46 @@ void codec_get_full_path(char *path, const char *codec_root_fn) | |||
197 | CODECS_DIR, codec_root_fn); | 185 | CODECS_DIR, codec_root_fn); |
198 | } | 186 | } |
199 | 187 | ||
200 | static int codec_load_ram(int size, struct codec_api *api) | 188 | static int codec_load_ram(void *handle, struct codec_api *api) |
201 | { | 189 | { |
202 | struct codec_header *hdr; | 190 | struct codec_header *hdr = lc_get_header(handle); |
203 | int status; | 191 | int status; |
204 | #if (CONFIG_PLATFORM & PLATFORM_NATIVE) | 192 | |
205 | hdr = (struct codec_header *)codecbuf; | 193 | if (hdr == NULL |
206 | |||
207 | if (size <= (signed)sizeof(struct codec_header) | ||
208 | || (hdr->magic != CODEC_MAGIC | 194 | || (hdr->magic != CODEC_MAGIC |
209 | #ifdef HAVE_RECORDING | 195 | #ifdef HAVE_RECORDING |
210 | && hdr->magic != CODEC_ENC_MAGIC | 196 | && hdr->magic != CODEC_ENC_MAGIC |
211 | #endif | 197 | #endif |
212 | ) | 198 | ) |
213 | || hdr->target_id != TARGET_ID | 199 | || hdr->target_id != TARGET_ID |
200 | #if (CONFIG_PLATFORM & PLATFORM_NATIVE) | ||
214 | || hdr->load_addr != codecbuf | 201 | || hdr->load_addr != codecbuf |
215 | || hdr->end_addr > codecbuf + CODEC_SIZE) | 202 | || hdr->end_addr > codecbuf + CODEC_SIZE |
203 | #endif | ||
204 | ) | ||
216 | { | 205 | { |
217 | logf("codec header error"); | 206 | logf("codec header error"); |
207 | lc_close(handle); | ||
218 | return CODEC_ERROR; | 208 | return CODEC_ERROR; |
219 | } | 209 | } |
220 | 210 | ||
221 | codec_size = hdr->end_addr - codecbuf; | ||
222 | |||
223 | #elif (CONFIG_PLATFORM & PLATFORM_HOSTED) | ||
224 | void *pd; | ||
225 | |||
226 | hdr = sim_codec_load_ram(codecbuf, size, &pd); | ||
227 | |||
228 | if (pd == NULL) | ||
229 | return CODEC_ERROR; | ||
230 | |||
231 | if (hdr == NULL | ||
232 | || (hdr->magic != CODEC_MAGIC | ||
233 | #ifdef HAVE_RECORDING | ||
234 | && hdr->magic != CODEC_ENC_MAGIC | ||
235 | #endif | ||
236 | ) | ||
237 | || hdr->target_id != TARGET_ID) { | ||
238 | sim_codec_close(pd); | ||
239 | return CODEC_ERROR; | ||
240 | } | ||
241 | |||
242 | codec_size = codecbuf - codecbuf; | ||
243 | |||
244 | #endif /* CONFIG_PLATFORM */ | ||
245 | if (hdr->api_version > CODEC_API_VERSION | 211 | if (hdr->api_version > CODEC_API_VERSION |
246 | || hdr->api_version < CODEC_MIN_API_VERSION) { | 212 | || hdr->api_version < CODEC_MIN_API_VERSION) { |
247 | sim_codec_close(pd); | 213 | logf("codec api version error"); |
214 | lc_close(handle); | ||
248 | return CODEC_ERROR; | 215 | return CODEC_ERROR; |
249 | } | 216 | } |
250 | 217 | ||
218 | #if (CONFIG_PLATFORM & PLATFORM_NATIVE) | ||
219 | codec_size = hdr->end_addr - codecbuf; | ||
220 | #else | ||
221 | codec_size = 0; | ||
222 | #endif | ||
223 | |||
251 | *(hdr->api) = api; | 224 | *(hdr->api) = api; |
252 | cpucache_invalidate(); | ||
253 | status = hdr->entry_point(); | 225 | status = hdr->entry_point(); |
254 | 226 | ||
255 | sim_codec_close(pd); | 227 | lc_close(handle); |
256 | 228 | ||
257 | return status; | 229 | return status; |
258 | } | 230 | } |
@@ -260,36 +232,37 @@ static int codec_load_ram(int size, struct codec_api *api) | |||
260 | int codec_load_buf(unsigned int hid, struct codec_api *api) | 232 | int codec_load_buf(unsigned int hid, struct codec_api *api) |
261 | { | 233 | { |
262 | int rc; | 234 | int rc; |
235 | void *handle; | ||
263 | rc = bufread(hid, CODEC_SIZE, codecbuf); | 236 | rc = bufread(hid, CODEC_SIZE, codecbuf); |
264 | if (rc < 0) { | 237 | if (rc < 0) { |
265 | logf("error loading codec"); | 238 | logf("error loading codec"); |
266 | return CODEC_ERROR; | 239 | return CODEC_ERROR; |
267 | } | 240 | } |
241 | handle = lc_open_from_mem(codecbuf, rc); | ||
242 | if (handle == NULL) | ||
243 | { | ||
244 | logf("error loading codec"); | ||
245 | return CODEC_ERROR; | ||
246 | } | ||
247 | |||
268 | api->discard_codec(); | 248 | api->discard_codec(); |
269 | return codec_load_ram(rc, api); | 249 | return codec_load_ram(handle, api); |
270 | } | 250 | } |
271 | 251 | ||
272 | int codec_load_file(const char *plugin, struct codec_api *api) | 252 | int codec_load_file(const char *plugin, struct codec_api *api) |
273 | { | 253 | { |
274 | char path[MAX_PATH]; | 254 | char path[MAX_PATH]; |
275 | int fd; | 255 | void *handle; |
276 | int rc; | ||
277 | 256 | ||
278 | codec_get_full_path(path, plugin); | 257 | codec_get_full_path(path, plugin); |
279 | 258 | ||
280 | fd = open(path, O_RDONLY); | 259 | handle = lc_open(path, codecbuf, CODEC_SIZE); |
281 | if (fd < 0) { | 260 | |
282 | logf("Codec load error:%d", fd); | 261 | if (handle == NULL) { |
262 | logf("Codec load error"); | ||
283 | splashf(HZ*2, "Couldn't load codec: %s", path); | 263 | splashf(HZ*2, "Couldn't load codec: %s", path); |
284 | return fd; | ||
285 | } | ||
286 | |||
287 | rc = read(fd, &codecbuf[0], CODEC_SIZE); | ||
288 | close(fd); | ||
289 | if (rc <= 0) { | ||
290 | logf("Codec read error"); | ||
291 | return CODEC_ERROR; | 264 | return CODEC_ERROR; |
292 | } | 265 | } |
293 | 266 | ||
294 | return codec_load_ram((size_t)rc, api); | 267 | return codec_load_ram(handle, api); |
295 | } | 268 | } |
diff --git a/apps/plugin.c b/apps/plugin.c index cc540cd988..53a05bf527 100644 --- a/apps/plugin.c +++ b/apps/plugin.c | |||
@@ -42,6 +42,7 @@ | |||
42 | #include "errno.h" | 42 | #include "errno.h" |
43 | #include "diacritic.h" | 43 | #include "diacritic.h" |
44 | #include "filefuncs.h" | 44 | #include "filefuncs.h" |
45 | #include "load_code.h" | ||
45 | 46 | ||
46 | #if CONFIG_CHARGING | 47 | #if CONFIG_CHARGING |
47 | #include "power.h" | 48 | #include "power.h" |
@@ -75,21 +76,19 @@ static unsigned int open_files; | |||
75 | 76 | ||
76 | #if (CONFIG_PLATFORM & PLATFORM_HOSTED) | 77 | #if (CONFIG_PLATFORM & PLATFORM_HOSTED) |
77 | static unsigned char pluginbuf[PLUGIN_BUFFER_SIZE]; | 78 | static unsigned char pluginbuf[PLUGIN_BUFFER_SIZE]; |
78 | void *sim_plugin_load(char *plugin, void **pd); | ||
79 | void sim_plugin_close(void *pd); | ||
80 | void sim_lcd_ex_init(unsigned long (*getpixel)(int, int)); | 79 | void sim_lcd_ex_init(unsigned long (*getpixel)(int, int)); |
81 | void sim_lcd_ex_update_rect(int x, int y, int width, int height); | 80 | void sim_lcd_ex_update_rect(int x, int y, int width, int height); |
82 | #else | 81 | #else |
83 | #define sim_plugin_close(x) | ||
84 | extern unsigned char pluginbuf[]; | 82 | extern unsigned char pluginbuf[]; |
85 | #include "bitswap.h" | 83 | #include "bitswap.h" |
86 | #endif | 84 | #endif |
87 | 85 | ||
88 | /* for actual plugins only, not for codecs */ | 86 | /* for actual plugins only, not for codecs */ |
89 | static bool plugin_loaded = false; | ||
90 | static int plugin_size = 0; | 87 | static int plugin_size = 0; |
91 | static bool (*pfn_tsr_exit)(bool reenter) = NULL; /* TSR exit callback */ | 88 | static bool (*pfn_tsr_exit)(bool reenter) = NULL; /* TSR exit callback */ |
92 | static char current_plugin[MAX_PATH]; | 89 | static char current_plugin[MAX_PATH]; |
90 | /* NULL if no plugin is loaded, otherwise the handle that lc_open() returned */ | ||
91 | static void *current_plugin_handle; | ||
93 | 92 | ||
94 | char *plugin_get_current_filename(void); | 93 | char *plugin_get_current_filename(void); |
95 | 94 | ||
@@ -728,98 +727,60 @@ int plugin_load(const char* plugin, const void* parameter) | |||
728 | { | 727 | { |
729 | int rc, i; | 728 | int rc, i; |
730 | struct plugin_header *hdr; | 729 | struct plugin_header *hdr; |
731 | #if (CONFIG_PLATFORM & PLATFORM_HOSTED) | ||
732 | void *pd; | ||
733 | #else /* PLATFOR_NATIVE */ | ||
734 | int fd; | ||
735 | ssize_t readsize; | ||
736 | #if NUM_CORES > 1 | ||
737 | unsigned my_core; | ||
738 | #endif | ||
739 | #endif /* CONFIG_PLATFORM */ | ||
740 | 730 | ||
741 | #if LCD_DEPTH > 1 | 731 | #if LCD_DEPTH > 1 |
742 | fb_data* old_backdrop; | 732 | fb_data* old_backdrop; |
743 | #endif | 733 | #endif |
744 | 734 | ||
745 | if (pfn_tsr_exit != NULL) /* if we have a resident old plugin: */ | 735 | if (current_plugin_handle && pfn_tsr_exit) |
746 | { | 736 | { /* if we have a resident old plugin and a callback */ |
747 | if (pfn_tsr_exit(!strcmp(current_plugin, plugin)) == false ) | 737 | if (pfn_tsr_exit(!strcmp(current_plugin, plugin)) == false ) |
748 | { | 738 | { |
749 | /* not allowing another plugin to load */ | 739 | /* not allowing another plugin to load */ |
750 | return PLUGIN_OK; | 740 | return PLUGIN_OK; |
751 | } | 741 | } |
752 | pfn_tsr_exit = NULL; | 742 | lc_close(current_plugin_handle); |
753 | plugin_loaded = false; | 743 | current_plugin_handle = pfn_tsr_exit = NULL; |
754 | } | 744 | } |
755 | 745 | ||
756 | splash(0, ID2P(LANG_WAIT)); | 746 | splash(0, ID2P(LANG_WAIT)); |
757 | strcpy(current_plugin, plugin); | 747 | strcpy(current_plugin, plugin); |
758 | 748 | ||
759 | #if (CONFIG_PLATFORM & PLATFORM_HOSTED) | 749 | current_plugin_handle = lc_open(plugin, pluginbuf, PLUGIN_BUFFER_SIZE); |
760 | hdr = sim_plugin_load((char *)plugin, &pd); | 750 | if (current_plugin_handle == NULL) { |
761 | if (pd == NULL) { | ||
762 | splashf(HZ*2, str(LANG_PLUGIN_CANT_OPEN), plugin); | 751 | splashf(HZ*2, str(LANG_PLUGIN_CANT_OPEN), plugin); |
763 | return -1; | 752 | return -1; |
764 | } | 753 | } |
765 | if (hdr == NULL | ||
766 | || hdr->magic != PLUGIN_MAGIC | ||
767 | || hdr->target_id != TARGET_ID) { | ||
768 | sim_plugin_close(pd); | ||
769 | splash(HZ*2, str(LANG_PLUGIN_WRONG_MODEL)); | ||
770 | return -1; | ||
771 | } | ||
772 | if (hdr->api_version > PLUGIN_API_VERSION | ||
773 | || hdr->api_version < PLUGIN_MIN_API_VERSION) { | ||
774 | sim_plugin_close(pd); | ||
775 | splash(HZ*2, str(LANG_PLUGIN_WRONG_VERSION)); | ||
776 | return -1; | ||
777 | } | ||
778 | #else | ||
779 | fd = open(plugin, O_RDONLY); | ||
780 | if (fd < 0) { | ||
781 | splashf(HZ*2, str(LANG_PLUGIN_CANT_OPEN), plugin); | ||
782 | return fd; | ||
783 | } | ||
784 | #if NUM_CORES > 1 | ||
785 | /* Make sure COP cache is flushed and invalidated before loading */ | ||
786 | my_core = switch_core(CURRENT_CORE ^ 1); | ||
787 | cpucache_invalidate(); | ||
788 | switch_core(my_core); | ||
789 | #endif | ||
790 | 754 | ||
791 | readsize = read(fd, pluginbuf, PLUGIN_BUFFER_SIZE); | 755 | hdr = lc_get_header(current_plugin_handle); |
792 | close(fd); | ||
793 | 756 | ||
794 | if (readsize < 0) { | 757 | if (hdr == NULL |
795 | splashf(HZ*2, str(LANG_READ_FAILED), plugin); | ||
796 | return -1; | ||
797 | } | ||
798 | hdr = (struct plugin_header *)pluginbuf; | ||
799 | |||
800 | if ((unsigned)readsize <= sizeof(struct plugin_header) | ||
801 | || hdr->magic != PLUGIN_MAGIC | 758 | || hdr->magic != PLUGIN_MAGIC |
802 | || hdr->target_id != TARGET_ID | 759 | || hdr->target_id != TARGET_ID |
760 | #if (CONFIG_PLATFORM & PLATFORM_NATIVE) | ||
803 | || hdr->load_addr != pluginbuf | 761 | || hdr->load_addr != pluginbuf |
804 | || hdr->end_addr > pluginbuf + PLUGIN_BUFFER_SIZE) { | 762 | || hdr->end_addr > pluginbuf + PLUGIN_BUFFER_SIZE |
763 | #endif | ||
764 | ) | ||
765 | { | ||
766 | lc_close(current_plugin_handle); | ||
805 | splash(HZ*2, str(LANG_PLUGIN_WRONG_MODEL)); | 767 | splash(HZ*2, str(LANG_PLUGIN_WRONG_MODEL)); |
806 | return -1; | 768 | return -1; |
807 | } | 769 | } |
808 | if (hdr->api_version > PLUGIN_API_VERSION | 770 | if (hdr->api_version > PLUGIN_API_VERSION |
809 | || hdr->api_version < PLUGIN_MIN_API_VERSION) { | 771 | || hdr->api_version < PLUGIN_MIN_API_VERSION) |
772 | { | ||
773 | lc_close(current_plugin_handle); | ||
810 | splash(HZ*2, str(LANG_PLUGIN_WRONG_VERSION)); | 774 | splash(HZ*2, str(LANG_PLUGIN_WRONG_VERSION)); |
811 | return -1; | 775 | return -1; |
812 | } | 776 | } |
777 | #if (CONFIG_PLATFORM & PLATFORM_NATIVE) | ||
813 | plugin_size = hdr->end_addr - pluginbuf; | 778 | plugin_size = hdr->end_addr - pluginbuf; |
814 | 779 | #else | |
815 | /* zero out bss area only, above guards end of pluginbuf */ | 780 | plugin_size = 0; |
816 | if (plugin_size > readsize) | ||
817 | memset(pluginbuf + readsize, 0, plugin_size - readsize); | ||
818 | #endif | 781 | #endif |
819 | 782 | ||
820 | *(hdr->api) = &rockbox_api; | 783 | *(hdr->api) = &rockbox_api; |
821 | plugin_loaded = true; | ||
822 | |||
823 | 784 | ||
824 | #if defined HAVE_LCD_BITMAP && LCD_DEPTH > 1 | 785 | #if defined HAVE_LCD_BITMAP && LCD_DEPTH > 1 |
825 | old_backdrop = lcd_get_backdrop(); | 786 | old_backdrop = lcd_get_backdrop(); |
@@ -834,8 +795,6 @@ int plugin_load(const char* plugin, const void* parameter) | |||
834 | 795 | ||
835 | FOR_NB_SCREENS(i) | 796 | FOR_NB_SCREENS(i) |
836 | viewportmanager_theme_enable(i, false, NULL); | 797 | viewportmanager_theme_enable(i, false, NULL); |
837 | |||
838 | cpucache_invalidate(); | ||
839 | 798 | ||
840 | #ifdef HAVE_TOUCHSCREEN | 799 | #ifdef HAVE_TOUCHSCREEN |
841 | touchscreen_set_mode(TOUCHSCREEN_BUTTON); | 800 | touchscreen_set_mode(TOUCHSCREEN_BUTTON); |
@@ -847,6 +806,12 @@ int plugin_load(const char* plugin, const void* parameter) | |||
847 | 806 | ||
848 | rc = hdr->entry_point(parameter); | 807 | rc = hdr->entry_point(parameter); |
849 | 808 | ||
809 | if (!pfn_tsr_exit) | ||
810 | { /* close handle if plugin is no tsr one */ | ||
811 | lc_close(current_plugin_handle); | ||
812 | current_plugin_handle = NULL; | ||
813 | } | ||
814 | |||
850 | /* Go back to the global setting in case the plugin changed it */ | 815 | /* Go back to the global setting in case the plugin changed it */ |
851 | #ifdef HAVE_TOUCHSCREEN | 816 | #ifdef HAVE_TOUCHSCREEN |
852 | touchscreen_set_mode(global_settings.touch_mode); | 817 | touchscreen_set_mode(global_settings.touch_mode); |
@@ -887,11 +852,8 @@ int plugin_load(const char* plugin, const void* parameter) | |||
887 | FOR_NB_SCREENS(i) | 852 | FOR_NB_SCREENS(i) |
888 | viewportmanager_theme_undo(i, false); | 853 | viewportmanager_theme_undo(i, false); |
889 | 854 | ||
890 | if (pfn_tsr_exit == NULL) | ||
891 | plugin_loaded = false; | ||
892 | |||
893 | #ifdef HAVE_PLUGIN_CHECK_OPEN_CLOSE | 855 | #ifdef HAVE_PLUGIN_CHECK_OPEN_CLOSE |
894 | if(open_files != 0 && !plugin_loaded) | 856 | if(open_files != 0 && !current_plugin_handle) |
895 | { | 857 | { |
896 | int fd; | 858 | int fd; |
897 | logf("Plugin '%s' leaks file handles", plugin); | 859 | logf("Plugin '%s' leaks file handles", plugin); |
@@ -909,8 +871,6 @@ int plugin_load(const char* plugin, const void* parameter) | |||
909 | } | 871 | } |
910 | #endif | 872 | #endif |
911 | 873 | ||
912 | sim_plugin_close(pd); | ||
913 | |||
914 | if (rc == PLUGIN_ERROR) | 874 | if (rc == PLUGIN_ERROR) |
915 | splash(HZ*2, str(LANG_PLUGIN_ERROR)); | 875 | splash(HZ*2, str(LANG_PLUGIN_ERROR)); |
916 | 876 | ||
@@ -923,7 +883,7 @@ void* plugin_get_buffer(size_t *buffer_size) | |||
923 | { | 883 | { |
924 | int buffer_pos; | 884 | int buffer_pos; |
925 | 885 | ||
926 | if (plugin_loaded) | 886 | if (current_plugin_handle) |
927 | { | 887 | { |
928 | if (plugin_size >= PLUGIN_BUFFER_SIZE) | 888 | if (plugin_size >= PLUGIN_BUFFER_SIZE) |
929 | return NULL; | 889 | return NULL; |
diff --git a/apps/plugins/plugin_crt0.c b/apps/plugins/plugin_crt0.c index 536eccaffa..e34124c5a2 100644 --- a/apps/plugins/plugin_crt0.c +++ b/apps/plugins/plugin_crt0.c | |||
@@ -32,6 +32,8 @@ PLUGIN_HEADER | |||
32 | #define EXIT_MAGIC 0x0CDEBABE | 32 | #define EXIT_MAGIC 0x0CDEBABE |
33 | 33 | ||
34 | extern enum plugin_status plugin_start(const void*); | 34 | extern enum plugin_status plugin_start(const void*); |
35 | extern unsigned char plugin_bss_start[]; | ||
36 | extern unsigned char plugin_end_addr[]; | ||
35 | 37 | ||
36 | static jmp_buf __exit_env; | 38 | static jmp_buf __exit_env; |
37 | /* only 1 atexit handler for now, chain in the exit handler if you need more */ | 39 | /* only 1 atexit handler for now, chain in the exit handler if you need more */ |
@@ -61,6 +63,10 @@ enum plugin_status plugin__start(const void *param) | |||
61 | int exit_ret; | 63 | int exit_ret; |
62 | enum plugin_status ret; | 64 | enum plugin_status ret; |
63 | 65 | ||
66 | /* zero out the bss section */ | ||
67 | #if (CONFIG_PLATFORM & PLATFORM_NATIVE) | ||
68 | rb->memset(plugin_bss_start, 0, plugin_end_addr - plugin_bss_start); | ||
69 | #endif | ||
64 | /* we come back here if exit() was called or the plugin returned normally */ | 70 | /* we come back here if exit() was called or the plugin returned normally */ |
65 | exit_ret = setjmp(__exit_env); | 71 | exit_ret = setjmp(__exit_env); |
66 | if (exit_ret == 0) | 72 | if (exit_ret == 0) |