Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 2 | * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * Licensed under the GPL |
| 4 | */ |
| 5 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | #include <stdio.h> |
| 7 | #include <stdlib.h> |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 8 | #include <unistd.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 9 | #include <errno.h> |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 10 | #include <signal.h> |
| 11 | #include <string.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | #include <sys/resource.h> |
Jeff Dike | 4ff83ce | 2007-05-06 14:51:08 -0700 | [diff] [blame] | 13 | #include "as-layout.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | #include "init.h" |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 15 | #include "kern_constants.h" |
| 16 | #include "kern_util.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | #include "os.h" |
Paolo 'Blaisorblade' Giarrusso | c13e569 | 2006-10-19 23:28:20 -0700 | [diff] [blame] | 18 | #include "um_malloc.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #define PGD_BOUND (4 * 1024 * 1024) |
| 21 | #define STACKSIZE (8 * 1024 * 1024) |
| 22 | #define THREAD_NAME_LEN (256) |
| 23 | |
| 24 | static void set_stklim(void) |
| 25 | { |
| 26 | struct rlimit lim; |
| 27 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 28 | if (getrlimit(RLIMIT_STACK, &lim) < 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | perror("getrlimit"); |
| 30 | exit(1); |
| 31 | } |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 32 | if ((lim.rlim_cur == RLIM_INFINITY) || (lim.rlim_cur > STACKSIZE)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | lim.rlim_cur = STACKSIZE; |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 34 | if (setrlimit(RLIMIT_STACK, &lim) < 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | perror("setrlimit"); |
| 36 | exit(1); |
| 37 | } |
| 38 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | } |
| 40 | |
| 41 | static __init void do_uml_initcalls(void) |
| 42 | { |
| 43 | initcall_t *call; |
| 44 | |
| 45 | call = &__uml_initcall_start; |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 46 | while (call < &__uml_initcall_end) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | (*call)(); |
| 48 | call++; |
| 49 | } |
| 50 | } |
| 51 | |
| 52 | static void last_ditch_exit(int sig) |
| 53 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | uml_cleanup(); |
| 55 | exit(1); |
| 56 | } |
| 57 | |
Jeff Dike | 4b84c69 | 2006-09-25 23:33:04 -0700 | [diff] [blame] | 58 | static 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 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 65 | /* |
| 66 | * ... including the signal being handled, plus we want the |
Jeff Dike | 4b84c69 | 2006-09-25 23:33:04 -0700 | [diff] [blame] | 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; |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 74 | if (sigaction(sig, &action, NULL) < 0) { |
Jeff Dike | 4b84c69 | 2006-09-25 23:33:04 -0700 | [diff] [blame] | 75 | printf("failed to install handler for signal %d - errno = %d\n", |
| 76 | errno); |
| 77 | exit(1); |
| 78 | } |
| 79 | } |
| 80 | |
Mattia Dongili | cb98cdc | 2006-05-01 12:16:01 -0700 | [diff] [blame] | 81 | #define UML_LIB_PATH ":/usr/lib/uml" |
| 82 | |
| 83 | static 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"); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 90 | /* |
| 91 | * if no PATH variable is set or it has an empty value |
Mattia Dongili | cb98cdc | 2006-05-01 12:16:01 -0700 | [diff] [blame] | 92 | * just use the default + /usr/lib/uml |
| 93 | */ |
| 94 | if (!old_path || (path_len = strlen(old_path)) == 0) { |
| 95 | putenv("PATH=:/bin:/usr/bin/" UML_LIB_PATH); |
| 96 | return; |
| 97 | } |
| 98 | |
| 99 | /* append /usr/lib/uml to the existing path */ |
| 100 | path_len += strlen("PATH=" UML_LIB_PATH) + 1; |
| 101 | new_path = malloc(path_len); |
| 102 | if (!new_path) { |
| 103 | perror("coudn't malloc to set a new PATH"); |
| 104 | return; |
| 105 | } |
| 106 | snprintf(new_path, path_len, "PATH=%s" UML_LIB_PATH, old_path); |
| 107 | putenv(new_path); |
| 108 | } |
| 109 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | extern int uml_exitcode; |
| 111 | |
| 112 | extern void scan_elf_aux( char **envp); |
| 113 | |
Jeff Dike | 36e4546 | 2007-05-06 14:51:11 -0700 | [diff] [blame] | 114 | int __init main(int argc, char **argv, char **envp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | { |
| 116 | char **new_argv; |
Jeff Dike | 92515da | 2005-05-28 15:51:56 -0700 | [diff] [blame] | 117 | int ret, i, err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | set_stklim(); |
| 120 | |
Mattia Dongili | cb98cdc | 2006-05-01 12:16:01 -0700 | [diff] [blame] | 121 | setup_env_path(); |
| 122 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | new_argv = malloc((argc + 1) * sizeof(char *)); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 124 | if (new_argv == NULL) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | perror("Mallocing argv"); |
| 126 | exit(1); |
| 127 | } |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 128 | for (i = 0; i < argc; i++) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | new_argv[i] = strdup(argv[i]); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 130 | if (new_argv[i] == NULL) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | perror("Mallocing an arg"); |
| 132 | exit(1); |
| 133 | } |
| 134 | } |
| 135 | new_argv[argc] = NULL; |
| 136 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 137 | /* |
| 138 | * Allow these signals to bring down a UML if all other |
Jeff Dike | 4b84c69 | 2006-09-25 23:33:04 -0700 | [diff] [blame] | 139 | * methods of control fail. |
| 140 | */ |
| 141 | install_fatal_handler(SIGINT); |
| 142 | install_fatal_handler(SIGTERM); |
| 143 | install_fatal_handler(SIGHUP); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 145 | scan_elf_aux(envp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | |
| 147 | do_uml_initcalls(); |
| 148 | ret = linux_main(argc, argv); |
| 149 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 150 | /* |
| 151 | * Disable SIGPROF - I have no idea why libc doesn't do this or turn |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 152 | * off the profiling time, but UML dies with a SIGPROF just before |
| 153 | * exiting when profiling is active. |
| 154 | */ |
| 155 | change_sig(SIGPROF, 0); |
| 156 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 157 | /* |
| 158 | * This signal stuff used to be in the reboot case. However, |
Jeff Dike | 52c653b | 2005-11-07 00:58:50 -0800 | [diff] [blame] | 159 | * sometimes a SIGVTALRM can come in when we're halting (reproducably |
| 160 | * when writing out gcov information, presumably because that takes |
| 161 | * some time) and cause a segfault. |
| 162 | */ |
Jeff Dike | 92515da | 2005-05-28 15:51:56 -0700 | [diff] [blame] | 163 | |
Jeff Dike | 61b63c5 | 2007-10-16 01:27:27 -0700 | [diff] [blame] | 164 | /* stop timers and set SIGVTALRM to be ignored */ |
Jeff Dike | 52c653b | 2005-11-07 00:58:50 -0800 | [diff] [blame] | 165 | disable_timer(); |
Jeff Dike | 92515da | 2005-05-28 15:51:56 -0700 | [diff] [blame] | 166 | |
Jeff Dike | 52c653b | 2005-11-07 00:58:50 -0800 | [diff] [blame] | 167 | /* disable SIGIO for the fds and set SIGIO to be ignored */ |
| 168 | err = deactivate_all_fds(); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 169 | if (err) |
Jeff Dike | 52c653b | 2005-11-07 00:58:50 -0800 | [diff] [blame] | 170 | printf("deactivate_all_fds failed, errno = %d\n", -err); |
Jeff Dike | 92515da | 2005-05-28 15:51:56 -0700 | [diff] [blame] | 171 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 172 | /* |
| 173 | * Let any pending signals fire now. This ensures |
Jeff Dike | 52c653b | 2005-11-07 00:58:50 -0800 | [diff] [blame] | 174 | * that they won't be delivered after the exec, when |
| 175 | * they are definitely not expected. |
| 176 | */ |
| 177 | unblock_signals(); |
Jeff Dike | 92515da | 2005-05-28 15:51:56 -0700 | [diff] [blame] | 178 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | /* Reboot */ |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 180 | if (ret) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | printf("\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | execvp(new_argv[0], new_argv); |
| 183 | perror("Failed to exec kernel"); |
| 184 | ret = 1; |
| 185 | } |
| 186 | printf("\n"); |
Jeff Dike | a5ed1ff | 2007-05-06 14:50:58 -0700 | [diff] [blame] | 187 | return uml_exitcode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | } |
| 189 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | extern void *__real_malloc(int); |
| 191 | |
| 192 | void *__wrap_malloc(int size) |
| 193 | { |
| 194 | void *ret; |
| 195 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 196 | if (!kmalloc_ok) |
Jeff Dike | a5ed1ff | 2007-05-06 14:50:58 -0700 | [diff] [blame] | 197 | return __real_malloc(size); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 198 | else if (size <= UM_KERN_PAGE_SIZE) |
Jeff Dike | c539ab73 | 2007-06-16 10:16:09 -0700 | [diff] [blame] | 199 | /* finding contiguous pages can be hard*/ |
Jeff Dike | e4c4bf99 | 2007-07-15 23:38:56 -0700 | [diff] [blame] | 200 | ret = kmalloc(size, UM_GFP_KERNEL); |
| 201 | else ret = vmalloc(size); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 202 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 203 | /* |
| 204 | * glibc people insist that if malloc fails, errno should be |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | * set by malloc as well. So we do. |
| 206 | */ |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 207 | if (ret == NULL) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | errno = ENOMEM; |
| 209 | |
Jeff Dike | a5ed1ff | 2007-05-06 14:50:58 -0700 | [diff] [blame] | 210 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | } |
| 212 | |
| 213 | void *__wrap_calloc(int n, int size) |
| 214 | { |
| 215 | void *ptr = __wrap_malloc(n * size); |
| 216 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 217 | if (ptr == NULL) |
Jeff Dike | a5ed1ff | 2007-05-06 14:50:58 -0700 | [diff] [blame] | 218 | return NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 219 | memset(ptr, 0, n * size); |
Jeff Dike | a5ed1ff | 2007-05-06 14:50:58 -0700 | [diff] [blame] | 220 | return ptr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | } |
| 222 | |
| 223 | extern void __real_free(void *); |
| 224 | |
| 225 | extern unsigned long high_physmem; |
| 226 | |
| 227 | void __wrap_free(void *ptr) |
| 228 | { |
| 229 | unsigned long addr = (unsigned long) ptr; |
| 230 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 231 | /* |
| 232 | * We need to know how the allocation happened, so it can be correctly |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | * freed. This is done by seeing what region of memory the pointer is |
| 234 | * in - |
| 235 | * physical memory - kmalloc/kfree |
| 236 | * kernel virtual memory - vmalloc/vfree |
| 237 | * anywhere else - malloc/free |
| 238 | * If kmalloc is not yet possible, then either high_physmem and/or |
| 239 | * end_vm are still 0 (as at startup), in which case we call free, or |
| 240 | * we have set them, but anyway addr has not been allocated from those |
| 241 | * areas. So, in both cases __real_free is called. |
| 242 | * |
| 243 | * CAN_KMALLOC is checked because it would be bad to free a buffer |
| 244 | * with kmalloc/vmalloc after they have been turned off during |
| 245 | * shutdown. |
| 246 | * XXX: However, we sometimes shutdown CAN_KMALLOC temporarily, so |
| 247 | * there is a possibility for memory leaks. |
| 248 | */ |
| 249 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 250 | if ((addr >= uml_physmem) && (addr < high_physmem)) { |
| 251 | if (kmalloc_ok) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | kfree(ptr); |
| 253 | } |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 254 | else if ((addr >= start_vm) && (addr < end_vm)) { |
| 255 | if (kmalloc_ok) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | vfree(ptr); |
| 257 | } |
| 258 | else __real_free(ptr); |
| 259 | } |