arch/um/main.c

   1 /*
   2  * Copyright (C) 2000, 2001 Jeff Dike (jdike@karaya.com)
   3  * Licensed under the GPL
   4  */
   5
   6 #include <unistd.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <signal.h>
  11 #include <sys/resource.h>
  12 #include <sys/mman.h>
  13 #include <sys/user.h>
  14 #include <asm/page.h>
  15 #include "user_util.h"
  16 #include "kern_util.h"
  17 #include "mem_user.h"
  18 #include "signal_user.h"
  19 #include "user.h"
  20 #include "init.h"
  21 #include "mode.h"
  22 #include "choose-mode.h"
  23 #include "uml-config.h"
  24
  25 /* Set in set_stklim, which is called from main and __wrap_malloc.
  26  * __wrap_malloc only calls it if main hasn't started.
  27  */
  28 unsigned long stacksizelim;
  29
  30 /* Set in main */
  31 char *linux_prog;
  32
  33 #define PGD_BOUND (4 * 1024 * 1024)
  34 #define STACKSIZE (8 * 1024 * 1024)
  35 #define THREAD_NAME_LEN (256)
  36
  37 static void set_stklim(void)
  38 {
  39         struct rlimit lim;
  40
  41         if(getrlimit(RLIMIT_STACK, &lim) < 0){
  42                 perror("getrlimit");
  43                 exit(1);
  44         }
  45         if((lim.rlim_cur == RLIM_INFINITY) || (lim.rlim_cur > STACKSIZE)){
  46                 lim.rlim_cur = STACKSIZE;
  47                 if(setrlimit(RLIMIT_STACK, &lim) < 0){
  48                         perror("setrlimit");
  49                         exit(1);
  50                 }
  51         }
  52         stacksizelim = (lim.rlim_cur + PGD_BOUND - 1) & ~(PGD_BOUND - 1);
  53 }
  54
  55 static __init void do_uml_initcalls(void)
  56 {
  57         initcall_t *call;
  58
  59         call = &__uml_initcall_start;
  60         while (call < &__uml_initcall_end){;
  61                 (*call)();
  62                 call++;
  63         }
  64 }
  65
  66 static void last_ditch_exit(int sig)
  67 {
  68         CHOOSE_MODE(kmalloc_ok = 0, (void) 0);
  69         signal(SIGINT, SIG_DFL);
  70         signal(SIGTERM, SIG_DFL);
  71         signal(SIGHUP, SIG_DFL);
  72         uml_cleanup();
  73         exit(1);
  74 }
  75
  76 extern int uml_exitcode;
  77
  78 int main(int argc, char **argv, char **envp)
  79 {
  80         char **new_argv;
  81         sigset_t mask;
  82         int ret, i;
  83
  84         /* Enable all signals except SIGIO - in some environments, we can
  85          * enter with some signals blocked
  86          */
  87
  88         sigemptyset(&mask);
  89         sigaddset(&mask, SIGIO);
  90         if(sigprocmask(SIG_SETMASK, &mask, NULL) < 0){
  91                 perror("sigprocmask");
  92                 exit(1);
  93         }
  94
  95 #ifdef UML_CONFIG_MODE_TT
  96         /* Allocate memory for thread command lines */
  97         if(argc < 2 || strlen(argv[1]) < THREAD_NAME_LEN - 1){
  98
  99                 char padding[THREAD_NAME_LEN] = {
 100                         [ 0 ...  THREAD_NAME_LEN - 2] = ' ', '\0'
 101                 };
 102
 103                 new_argv = malloc((argc + 2) * sizeof(char*));
 104                 if(!new_argv) {
 105                         perror("Allocating extended argv");
 106                         exit(1);
 107                 }
 108
 109                 new_argv[0] = argv[0];
 110                 new_argv[1] = padding;
 111
 112                 for(i = 2; i <= argc; i++)
 113                         new_argv[i] = argv[i - 1];
 114                 new_argv[argc + 1] = NULL;
 115
 116                 execvp(new_argv[0], new_argv);
 117                 perror("execing with extended args");
 118                 exit(1);
 119         }
 120 #endif
 121
 122         linux_prog = argv[0];
 123
 124         set_stklim();
 125
 126         if((new_argv = malloc((argc + 1) * sizeof(char *))) == NULL){
 127                 perror("Mallocing argv");
 128                 exit(1);
 129         }
 130         for(i=0;i<argc;i++){
 131                 if((new_argv[i] = strdup(argv[i])) == NULL){
 132                         perror("Mallocing an arg");
 133                         exit(1);
 134                 }
 135         }
 136         new_argv[argc] = NULL;
 137
 138         set_handler(SIGINT, last_ditch_exit, SA_ONESHOT | SA_NODEFER, -1);
 139         set_handler(SIGTERM, last_ditch_exit, SA_ONESHOT | SA_NODEFER, -1);
 140         set_handler(SIGHUP, last_ditch_exit, SA_ONESHOT | SA_NODEFER, -1);
 141
 142         do_uml_initcalls();
 143         ret = linux_main(argc, argv);
 144
 145         /* Reboot */
 146         if(ret){
 147                 printf("\n");
 148                 execvp(new_argv[0], new_argv);
 149                 perror("Failed to exec kernel");
 150                 ret = 1;
 151         }
 152         printf("\n");
 153         return(uml_exitcode);
 154 }
 155
 156 #define CAN_KMALLOC() \
 157         (kmalloc_ok && CHOOSE_MODE((getpid() != tracing_pid), 1))
 158
 159 extern void *__real_malloc(int);
 160
 161 void *__wrap_malloc(int size)
 162 {
 163         if(CAN_KMALLOC())
 164                 return(um_kmalloc(size));
 165         else
 166                 return(__real_malloc(size));
 167 }
 168
 169 void *__wrap_calloc(int n, int size)
 170 {
 171         void *ptr = __wrap_malloc(n * size);
 172
 173         if(ptr == NULL) return(NULL);
 174         memset(ptr, 0, n * size);
 175         return(ptr);
 176 }
 177
 178 extern void __real_free(void *);
 179
 180 void __wrap_free(void *ptr)
 181 {
 182         if(CAN_KMALLOC()) kfree(ptr);
 183         else __real_free(ptr);
 184 }
 185
 186 /*
 187  * Overrides for Emacs so that we follow Linus's tabbing style.
 188  * Emacs will notice this stuff at the end of the file and automatically
 189  * adjust the settings for this buffer only.  This must remain at the end
 190  * of the file.
 191  * ---------------------------------------------------------------------------
 192  * Local variables:
 193  * c-file-style: "linux"
 194  * End:
 195  */