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