kernel/arch/um/os-Linux/util.c

   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 <termios.h>
  13 #include <wait.h>
  14 #include <sys/mman.h>
  15 #include <sys/utsname.h>
  16 #include <os.h>
  17
  18 void stack_protections(unsigned long address)
  19 {
  20         if (mprotect((void *) address, UM_THREAD_SIZE,
  21                     PROT_READ | PROT_WRITE | PROT_EXEC) < 0)
  22                 panic("protecting stack failed, errno = %d", errno);
  23 }
  24
  25 int raw(int fd)
  26 {
  27         struct termios tt;
  28         int err;
  29
  30         CATCH_EINTR(err = tcgetattr(fd, &tt));
  31         if (err < 0)
  32                 return -errno;
  33
  34         cfmakeraw(&tt);
  35
  36         CATCH_EINTR(err = tcsetattr(fd, TCSADRAIN, &tt));
  37         if (err < 0)
  38                 return -errno;
  39
  40         /*
  41          * XXX tcsetattr could have applied only some changes
  42          * (and cfmakeraw() is a set of changes)
  43          */
  44         return 0;
  45 }
  46
  47 void setup_machinename(char *machine_out)
  48 {
  49         struct utsname host;
  50
  51         uname(&host);
  52 #ifdef UML_CONFIG_UML_X86
  53 # ifndef UML_CONFIG_64BIT
  54         if (!strcmp(host.machine, "x86_64")) {
  55                 strcpy(machine_out, "i686");
  56                 return;
  57         }
  58 # else
  59         if (!strcmp(host.machine, "i686")) {
  60                 strcpy(machine_out, "x86_64");
  61                 return;
  62         }
  63 # endif
  64 #endif
  65         strcpy(machine_out, host.machine);
  66 }
  67
  68 void setup_hostinfo(char *buf, int len)
  69 {
  70         struct utsname host;
  71
  72         uname(&host);
  73         snprintf(buf, len, "%s %s %s %s %s", host.sysname, host.nodename,
  74                  host.release, host.version, host.machine);
  75 }
  76
  77 /*
  78  * We cannot use glibc's abort(). It makes use of tgkill() which
  79  * has no effect within UML's kernel threads.
  80  * After that glibc would execute an invalid instruction to kill
  81  * the calling process and UML crashes with SIGSEGV.
  82  */
  83 static inline void __attribute__ ((noreturn)) uml_abort(void)
  84 {
  85         sigset_t sig;
  86
  87         fflush(NULL);
  88
  89         if (!sigemptyset(&sig) && !sigaddset(&sig, SIGABRT))
  90                 sigprocmask(SIG_UNBLOCK, &sig, 0);
  91
  92         for (;;)
  93                 if (kill(getpid(), SIGABRT) < 0)
  94                         exit(127);
  95 }
  96
  97 /*
  98  * UML helper threads must not handle SIGWINCH/INT/TERM
  99  */
 100 void os_fix_helper_signals(void)
 101 {
 102         signal(SIGWINCH, SIG_IGN);
 103         signal(SIGINT, SIG_DFL);
 104         signal(SIGTERM, SIG_DFL);
 105 }
 106
 107 void os_dump_core(void)
 108 {
 109         int pid;
 110
 111         signal(SIGSEGV, SIG_DFL);
 112
 113         /*
 114          * We are about to SIGTERM this entire process group to ensure that
 115          * nothing is around to run after the kernel exits.  The
 116          * kernel wants to abort, not die through SIGTERM, so we
 117          * ignore it here.
 118          */
 119
 120         signal(SIGTERM, SIG_IGN);
 121         kill(0, SIGTERM);
 122         /*
 123          * Most of the other processes associated with this UML are
 124          * likely sTopped, so give them a SIGCONT so they see the
 125          * SIGTERM.
 126          */
 127         kill(0, SIGCONT);
 128
 129         /*
 130          * Now, having sent signals to everyone but us, make sure they
 131          * die by ptrace.  Processes can survive what's been done to
 132          * them so far - the mechanism I understand is receiving a
 133          * SIGSEGV and segfaulting immediately upon return.  There is
 134          * always a SIGSEGV pending, and (I'm guessing) signals are
 135          * processed in numeric order so the SIGTERM (signal 15 vs
 136          * SIGSEGV being signal 11) is never handled.
 137          *
 138          * Run a waitpid loop until we get some kind of error.
 139          * Hopefully, it's ECHILD, but there's not a lot we can do if
 140          * it's something else.  Tell os_kill_ptraced_process not to
 141          * wait for the child to report its death because there's
 142          * nothing reasonable to do if that fails.
 143          */
 144
 145         while ((pid = waitpid(-1, NULL, WNOHANG | __WALL)) > 0)
 146                 os_kill_ptraced_process(pid, 0);
 147
 148         uml_abort();
 149 }
 150
 151 void um_early_printk(const char *s, unsigned int n)
 152 {
 153         printf("%.*s", n, s);
 154 }