2 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3 * Licensed under the GPL
12 #include <sys/resource.h>
13 #include <as-layout.h>
15 #include <kern_util.h>
17 #include <um_malloc.h>
19 #define PGD_BOUND (4 * 1024 * 1024)
20 #define STACKSIZE (8 * 1024 * 1024)
21 #define THREAD_NAME_LEN (256)
25 static void set_stklim(void)
29 if (getrlimit(RLIMIT_STACK
, &lim
) < 0) {
33 if ((lim
.rlim_cur
== RLIM_INFINITY
) || (lim
.rlim_cur
> STACKSIZE
)) {
34 lim
.rlim_cur
= STACKSIZE
;
35 if (setrlimit(RLIMIT_STACK
, &lim
) < 0) {
42 static __init
void do_uml_initcalls(void)
46 call
= &__uml_initcall_start
;
47 while (call
< &__uml_initcall_end
) {
53 static void last_ditch_exit(int sig
)
59 static void install_fatal_handler(int sig
)
61 struct sigaction action
;
63 /* All signals are enabled in this handler ... */
64 sigemptyset(&action
.sa_mask
);
67 * ... including the signal being handled, plus we want the
68 * handler reset to the default behavior, so that if an exit
69 * handler is hanging for some reason, the UML will just die
70 * after this signal is sent a second time.
72 action
.sa_flags
= SA_RESETHAND
| SA_NODEFER
;
73 action
.sa_restorer
= NULL
;
74 action
.sa_handler
= last_ditch_exit
;
75 if (sigaction(sig
, &action
, NULL
) < 0) {
76 printf("failed to install handler for signal %d - errno = %d\n",
82 #define UML_LIB_PATH ":" OS_LIB_PATH "/uml"
84 static void setup_env_path(void)
86 char *new_path
= NULL
;
87 char *old_path
= NULL
;
90 old_path
= getenv("PATH");
92 * if no PATH variable is set or it has an empty value
93 * just use the default + /usr/lib/uml
95 if (!old_path
|| (path_len
= strlen(old_path
)) == 0) {
96 if (putenv("PATH=:/bin:/usr/bin/" UML_LIB_PATH
))
97 perror("couldn't putenv");
101 /* append /usr/lib/uml to the existing path */
102 path_len
+= strlen("PATH=" UML_LIB_PATH
) + 1;
103 new_path
= malloc(path_len
);
105 perror("couldn't malloc to set a new PATH");
108 snprintf(new_path
, path_len
, "PATH=%s" UML_LIB_PATH
, old_path
);
109 if (putenv(new_path
)) {
110 perror("couldn't putenv to set a new PATH");
115 extern void scan_elf_aux( char **envp
);
117 int __init
main(int argc
, char **argv
, char **envp
)
128 new_argv
= malloc((argc
+ 1) * sizeof(char *));
129 if (new_argv
== NULL
) {
130 perror("Mallocing argv");
133 for (i
= 0; i
< argc
; i
++) {
134 new_argv
[i
] = strdup(argv
[i
]);
135 if (new_argv
[i
] == NULL
) {
136 perror("Mallocing an arg");
140 new_argv
[argc
] = NULL
;
143 * Allow these signals to bring down a UML if all other
144 * methods of control fail.
146 install_fatal_handler(SIGINT
);
147 install_fatal_handler(SIGTERM
);
149 #ifdef CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA
154 ret
= linux_main(argc
, argv
);
157 * Disable SIGPROF - I have no idea why libc doesn't do this or turn
158 * off the profiling time, but UML dies with a SIGPROF just before
159 * exiting when profiling is active.
161 change_sig(SIGPROF
, 0);
164 * This signal stuff used to be in the reboot case. However,
165 * sometimes a SIGVTALRM can come in when we're halting (reproducably
166 * when writing out gcov information, presumably because that takes
167 * some time) and cause a segfault.
170 /* stop timers and set SIGVTALRM to be ignored */
173 /* disable SIGIO for the fds and set SIGIO to be ignored */
174 err
= deactivate_all_fds();
176 printf("deactivate_all_fds failed, errno = %d\n", -err
);
179 * Let any pending signals fire now. This ensures
180 * that they won't be delivered after the exec, when
181 * they are definitely not expected.
188 execvp(new_argv
[0], new_argv
);
189 perror("Failed to exec kernel");
196 extern void *__real_malloc(int);
198 void *__wrap_malloc(int size
)
203 return __real_malloc(size
);
204 else if (size
<= UM_KERN_PAGE_SIZE
)
205 /* finding contiguous pages can be hard*/
206 ret
= uml_kmalloc(size
, UM_GFP_KERNEL
);
207 else ret
= vmalloc(size
);
210 * glibc people insist that if malloc fails, errno should be
211 * set by malloc as well. So we do.
219 void *__wrap_calloc(int n
, int size
)
221 void *ptr
= __wrap_malloc(n
* size
);
225 memset(ptr
, 0, n
* size
);
229 extern void __real_free(void *);
231 extern unsigned long high_physmem
;
233 void __wrap_free(void *ptr
)
235 unsigned long addr
= (unsigned long) ptr
;
238 * We need to know how the allocation happened, so it can be correctly
239 * freed. This is done by seeing what region of memory the pointer is
241 * physical memory - kmalloc/kfree
242 * kernel virtual memory - vmalloc/vfree
243 * anywhere else - malloc/free
244 * If kmalloc is not yet possible, then either high_physmem and/or
245 * end_vm are still 0 (as at startup), in which case we call free, or
246 * we have set them, but anyway addr has not been allocated from those
247 * areas. So, in both cases __real_free is called.
249 * CAN_KMALLOC is checked because it would be bad to free a buffer
250 * with kmalloc/vmalloc after they have been turned off during
252 * XXX: However, we sometimes shutdown CAN_KMALLOC temporarily, so
253 * there is a possibility for memory leaks.
256 if ((addr
>= uml_physmem
) && (addr
< high_physmem
)) {
260 else if ((addr
>= start_vm
) && (addr
< end_vm
)) {
264 else __real_free(ptr
);