com32/lib/sys/module/exec.c

   1 /*
   2  * exec.c
   3  *
   4  *  Created on: Aug 14, 2008
   5  *      Author: Stefan Bucur <stefanb@zytor.com>
   6  */
   7
   8 #include <sys/module.h>
   9 #include <sys/exec.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <stdarg.h>
  14 #include <setjmp.h>
  15 #include <setjmp.h>
  16 #include <alloca.h>
  17 #include <dprintf.h>
  18
  19 #define DBG_PRINT(fmt, args...) dprintf("[EXEC] " fmt, ##args)
  20
  21 static struct elf_module    *mod_root = NULL;
  22 struct elf_module *__syslinux_current = NULL;
  23
  24 int exec_init(void)
  25 {
  26         int res;
  27
  28         res = modules_init();
  29         if (res != 0)
  30                 return res;
  31
  32         // Load the root module
  33         mod_root = module_alloc(EXEC_ROOT_NAME);
  34
  35         if (mod_root == NULL)
  36                 return -1;
  37
  38         res = module_load_shallow(mod_root, 0);
  39         if (res != 0) {
  40                 mod_root = NULL;
  41                 return res;
  42         }
  43
  44         return 0;
  45 }
  46
  47 int get_module_type(struct elf_module *module)
  48 {
  49         if(module->main_func) return EXEC_MODULE;
  50         return LIB_MODULE;
  51 }
  52
  53 jmp_buf __process_exit_jmp;
  54
  55 #if 0
  56 int spawnv(const char *name, const char **argv)
  57 {
  58         int res, ret_val = 0;
  59         const char **arg;
  60         int argc;
  61         char **argp, **args;
  62         struct elf_module *previous;
  63         malloc_tag_t prev_mem_tag;
  64
  65         struct elf_module *module = module_alloc(name);
  66
  67         if (module == NULL)
  68                 return -1;
  69
  70         res = module_load(module);
  71         if (res != 0) {
  72                 module_unload(module);
  73                 return res;
  74         }
  75
  76         if (module->main_func == NULL) {
  77                 // We can't execute without a main function
  78                 module_unload(module);
  79                 return -1;
  80         }
  81         /*if (module->main_func != NULL) {
  82                 const char **last_arg = argv;
  83                 void *old_tag;
  84                 while (*last_arg != NULL)
  85                         last_arg++;
  86
  87                 // Setup the memory allocation context
  88                 old_tag = __mem_get_tag_global();
  89                 __mem_set_tag_global(module);
  90
  91                 // Execute the program
  92                 ret_val = (*(module->main_func))(last_arg - argv, argv);
  93
  94                 // Clean up the allocation context
  95                 __free_tagged(module);
  96                 // Restore the allocation context
  97                 __mem_set_tag_global(old_tag);
  98         } else {
  99                 // We can't execute without a main function
 100                 module_unload(module);
 101                 return -1;
 102         }*/
 103         // Set up the process context
 104         previous = __syslinux_current;
 105         prev_mem_tag = __mem_get_tag_global();
 106
 107         // Setup the new process context
 108         __syslinux_current = module;
 109         __mem_set_tag_global((malloc_tag_t)module);
 110
 111         // Generate a new process copy of argv (on the stack)
 112         argc = 0;
 113         for (arg = argv; *arg; arg++)
 114                 argc++;
 115
 116         args = alloca((argc+1) * sizeof(char *));
 117
 118         for (arg = argv, argp = args; *arg; arg++, argp++) {
 119                 size_t l = strlen(*arg)+1;
 120                 *argp = alloca(l);
 121                 memcpy(*argp, *arg, l);
 122         }
 123
 124         *args = NULL;
 125
 126         // Execute the program
 127         ret_val = setjmp(module->u.x.process_exit);
 128
 129         if (ret_val)
 130                 ret_val--;              /* Valid range is 0-255 */
 131         else if (!module->main_func)
 132                 ret_val = -1;
 133         else
 134                 exit((module->main_func)(argc, args)); /* Actually run! */
 135
 136         // Clean up the allocation context
 137         __free_tagged(module);
 138         // Restore the allocation context
 139         __mem_set_tag_global(prev_mem_tag);
 140         // Restore the process context
 141         __syslinux_current = previous;
 142
 143         res = module_unload(module);
 144
 145         if (res != 0) {
 146                 return res;
 147         }
 148
 149         return ((unsigned int)ret_val & 0xFF);
 150 }
 151
 152 int spawnl(const char *name, const char *arg, ...)
 153 {
 154         /*
 155          * NOTE: We assume the standard ABI specification for the i386
 156          * architecture. This code may not work if used in other
 157          * circumstances, including non-variadic functions, different
 158          * architectures and calling conventions.
 159          */
 160         return spawnv(name, &arg);
 161 }
 162 #endif
 163
 164 struct elf_module *cur_module;
 165
 166 /*
 167  * Load a module and runs its start function.
 168  *
 169  * For library modules the start function is module->init_func and for
 170  * executable modules its module->main_func.
 171  *
 172  * "name" is the name of the module to load.
 173  *
 174  * "argv" and "argc" are only passed to module->main_func, for library
 175  * modules these arguments can be NULL and 0, respectively.
 176  *
 177  * "argv" is an array of arguments to pass to module->main_func.
 178  * argv[0] must be a pointer to "name" and argv[argc] must be NULL.
 179  *
 180  * "argc" is the number of arguments in "argv".
 181  */
 182 int spawn_load(const char *name, int argc, char **argv)
 183 {
 184         int res, ret_val = 0;
 185         struct elf_module *previous;
 186         //malloc_tag_t prev_mem_tag;
 187         struct elf_module *module = module_alloc(name);
 188         struct elf_module *prev_module;
 189         int type;
 190
 191         dprintf("enter: name = %s", name);
 192
 193         if (module == NULL)
 194                 return -1;
 195
 196         if (get_module_type(module) == EXEC_MODULE) {
 197                 if (!argc || !argv || strcmp(argv[0], name)) {
 198                         res = -1;
 199                         goto out;
 200                 }
 201         }
 202
 203         if (!strcmp(cur_module->name, module->name)) {
 204                 dprintf("We is running this module %s already!", module->name);
 205
 206                 /*
 207                  * If we're already running the module and it's of
 208                  * type EXEC_MODULE, then just return. We don't reload
 209                  * the module because that might cause us to re-run
 210                  * the init functions, which will cause us to run the
 211                  * main function, which will take control of this
 212                  * process.
 213                  *
 214                  * This can happen if some other EXEC_MODULE is
 215                  * resolving a symbol that is exported by the current
 216                  * EXEC_MODULE.
 217                  */
 218                 if (get_module_type(module) == EXEC_MODULE)
 219                         return 0;
 220         }
 221
 222         res = module_load(module);
 223         if (res != 0)
 224                 goto out;
 225
 226         type = get_module_type(module);
 227         prev_module = cur_module;
 228         cur_module = module;
 229
 230         dprintf("type = %d, prev = %s, cur = %s",
 231                 type, prev_module->name, cur_module->name);
 232
 233         if(type==EXEC_MODULE)
 234         {
 235                 previous = __syslinux_current;
 236                 //prev_mem_tag = __mem_get_tag_global();
 237
 238                 // Setup the new process context
 239                 __syslinux_current = module;
 240                 //__mem_set_tag_global((malloc_tag_t)module);
 241
 242                 // Execute the program
 243                 ret_val = setjmp(module->u.x.process_exit);
 244
 245                 if (ret_val)
 246                         ret_val--;              /* Valid range is 0-255 */
 247                 else if (!module->main_func)
 248                         ret_val = -1;
 249                 else
 250                         exit((module->main_func)(argc, argv)); /* Actually run! */
 251
 252                 // Clean up the allocation context
 253                 //__free_tagged(module);
 254                 // Restore the allocation context
 255                 //__mem_set_tag_global(prev_mem_tag);
 256                 // Restore the process context
 257                 __syslinux_current = previous;
 258
 259                 cur_module = prev_module;
 260                 res = module_unload(module);
 261
 262                 if (res != 0)
 263                         goto out;
 264         }
 265
 266 out:
 267         if (res)
 268                 _module_unload(module);
 269         return res;
 270 }
 271
 272 void exec_term(void)
 273 {
 274         modules_term();
 275 }