1/* 2 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) 3 * Licensed under the GPL 4 */ 5 6#include <stdio.h> 7#include <stdlib.h> 8#include <unistd.h> 9#include <errno.h> 10#include <signal.h> 11#include <string.h> 12#include <sys/resource.h> 13#include "as-layout.h" 14#include "init.h" 15#include "kern_constants.h" 16#include "kern_util.h" 17#include "os.h" 18#include "um_malloc.h" 19 20#define PGD_BOUND (4 * 1024 * 1024) 21#define STACKSIZE (8 * 1024 * 1024) 22#define THREAD_NAME_LEN (256) 23 24static void set_stklim(void) 25{ 26 struct rlimit lim; 27 28 if (getrlimit(RLIMIT_STACK, &lim) < 0) { 29 perror("getrlimit"); 30 exit(1); 31 } 32 if ((lim.rlim_cur == RLIM_INFINITY) || (lim.rlim_cur > STACKSIZE)) { 33 lim.rlim_cur = STACKSIZE; 34 if (setrlimit(RLIMIT_STACK, &lim) < 0) { 35 perror("setrlimit"); 36 exit(1); 37 } 38 } 39} 40 41static __init void do_uml_initcalls(void) 42{ 43 initcall_t *call; 44 45 call = &__uml_initcall_start; 46 while (call < &__uml_initcall_end) { 47 (*call)(); 48 call++; 49 } 50} 51 52static void last_ditch_exit(int sig) 53{ 54 uml_cleanup(); 55 exit(1); 56} 57 58static void install_fatal_handler(int sig) 59{ 60 struct sigaction action; 61 62 /* All signals are enabled in this handler ... */ 63 sigemptyset(&action.sa_mask); 64 65 /* 66 * ... including the signal being handled, plus we want the 67 * handler reset to the default behavior, so that if an exit 68 * handler is hanging for some reason, the UML will just die 69 * after this signal is sent a second time. 70 */ 71 action.sa_flags = SA_RESETHAND | SA_NODEFER; 72 action.sa_restorer = NULL; 73 action.sa_handler = last_ditch_exit; 74 if (sigaction(sig, &action, NULL) < 0) { 75 printf("failed to install handler for signal %d - errno = %d\n", 76 sig, errno); 77 exit(1); 78 } 79} 80 81#define UML_LIB_PATH ":/usr/lib/uml" 82 83static void setup_env_path(void) 84{ 85 char *new_path = NULL; 86 char *old_path = NULL; 87 int path_len = 0; 88 89 old_path = getenv("PATH"); 90 /* 91 * if no PATH variable is set or it has an empty value 92 * just use the default + /usr/lib/uml 93 */ 94 if (!old_path || (path_len = strlen(old_path)) == 0) { 95 if (putenv("PATH=:/bin:/usr/bin/" UML_LIB_PATH)) 96 perror("couldn't putenv"); 97 return; 98 } 99 100 /* append /usr/lib/uml to the existing path */ 101 path_len += strlen("PATH=" UML_LIB_PATH) + 1; 102 new_path = malloc(path_len); 103 if (!new_path) { 104 perror("couldn't malloc to set a new PATH"); 105 return; 106 } 107 snprintf(new_path, path_len, "PATH=%s" UML_LIB_PATH, old_path); 108 if (putenv(new_path)) { 109 perror("couldn't putenv to set a new PATH"); 110 free(new_path); 111 } 112} 113 114extern void scan_elf_aux( char **envp); 115 116int __init main(int argc, char **argv, char **envp) 117{ 118 char **new_argv; 119 int ret, i, err; 120 121 set_stklim(); 122 123 setup_env_path(); 124 125 new_argv = malloc((argc + 1) * sizeof(char *)); 126 if (new_argv == NULL) { 127 perror("Mallocing argv"); 128 exit(1); 129 } 130 for (i = 0; i < argc; i++) { 131 new_argv[i] = strdup(argv[i]); 132 if (new_argv[i] == NULL) { 133 perror("Mallocing an arg"); 134 exit(1); 135 } 136 } 137 new_argv[argc] = NULL; 138 139 /* 140 * Allow these signals to bring down a UML if all other 141 * methods of control fail. 142 */ 143 install_fatal_handler(SIGINT); 144 install_fatal_handler(SIGTERM); 145 install_fatal_handler(SIGHUP); 146 147 scan_elf_aux(envp); 148 149 do_uml_initcalls(); 150 ret = linux_main(argc, argv); 151 152 /* 153 * Disable SIGPROF - I have no idea why libc doesn't do this or turn 154 * off the profiling time, but UML dies with a SIGPROF just before 155 * exiting when profiling is active. 156 */ 157 change_sig(SIGPROF, 0); 158 159 /* 160 * This signal stuff used to be in the reboot case. However, 161 * sometimes a SIGVTALRM can come in when we're halting (reproducably 162 * when writing out gcov information, presumably because that takes 163 * some time) and cause a segfault. 164 */ 165 166 /* stop timers and set SIGVTALRM to be ignored */ 167 disable_timer(); 168 169 /* disable SIGIO for the fds and set SIGIO to be ignored */ 170 err = deactivate_all_fds(); 171 if (err) 172 printf("deactivate_all_fds failed, errno = %d\n", -err); 173 174 /* 175 * Let any pending signals fire now. This ensures 176 * that they won't be delivered after the exec, when 177 * they are definitely not expected. 178 */ 179 unblock_signals(); 180 181 /* Reboot */ 182 if (ret) { 183 printf("\n"); 184 execvp(new_argv[0], new_argv); 185 perror("Failed to exec kernel"); 186 ret = 1; 187 } 188 printf("\n"); 189 return uml_exitcode; 190} 191 192extern void *__real_malloc(int); 193 194void *__wrap_malloc(int size) 195{ 196 void *ret; 197 198 if (!kmalloc_ok) 199 return __real_malloc(size); 200 else if (size <= UM_KERN_PAGE_SIZE) 201 /* finding contiguous pages can be hard*/ 202 ret = uml_kmalloc(size, UM_GFP_KERNEL); 203 else ret = vmalloc(size); 204 205 /* 206 * glibc people insist that if malloc fails, errno should be 207 * set by malloc as well. So we do. 208 */ 209 if (ret == NULL) 210 errno = ENOMEM; 211 212 return ret; 213} 214 215void *__wrap_calloc(int n, int size) 216{ 217 void *ptr = __wrap_malloc(n * size); 218 219 if (ptr == NULL) 220 return NULL; 221 memset(ptr, 0, n * size); 222 return ptr; 223} 224 225extern void __real_free(void *); 226 227extern unsigned long high_physmem; 228 229void __wrap_free(void *ptr) 230{ 231 unsigned long addr = (unsigned long) ptr; 232 233 234 if ((addr >= uml_physmem) && (addr < high_physmem)) { 235 if (kmalloc_ok) 236 kfree(ptr); 237 } 238 else if ((addr >= start_vm) && (addr < end_vm)) { 239 if (kmalloc_ok) 240 vfree(ptr); 241 } 242 else __real_free(ptr); 243} 244