arch/um/os-Linux/util.c

   1 /*
   2  * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
   3  * Licensed under the GPL
   4  */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <unistd.h>
   9 #include <limits.h>
  10 #include <sys/mman.h>
  11 #include <sys/stat.h>
  12 #include <sys/utsname.h>
  13 #include <sys/param.h>
  14 #include <sys/time.h>
  15 #include "asm/types.h"
  16 #include <ctype.h>
  17 #include <signal.h>
  18 #include <wait.h>
  19 #include <errno.h>
  20 #include <stdarg.h>
  21 #include <sched.h>
  22 #include <termios.h>
  23 #include <string.h>
  24 #include "kern_util.h"
  25 #include "user.h"
  26 #include "mem_user.h"
  27 #include "init.h"
  28 #include "ptrace_user.h"
  29 #include "uml-config.h"
  30 #include "os.h"
  31 #include "longjmp.h"
  32 #include "kern_constants.h"
  33
  34 void stack_protections(unsigned long address)
  35 {
  36         if(mprotect((void *) address, UM_THREAD_SIZE,
  37                     PROT_READ | PROT_WRITE | PROT_EXEC) < 0)
  38                 panic("protecting stack failed, errno = %d", errno);
  39 }
  40
  41 int raw(int fd)
  42 {
  43         struct termios tt;
  44         int err;
  45
  46         CATCH_EINTR(err = tcgetattr(fd, &tt));
  47         if(err < 0)
  48                 return -errno;
  49
  50         cfmakeraw(&tt);
  51
  52         CATCH_EINTR(err = tcsetattr(fd, TCSADRAIN, &tt));
  53         if(err < 0)
  54                 return -errno;
  55
  56         /* XXX tcsetattr could have applied only some changes
  57          * (and cfmakeraw() is a set of changes) */
  58         return 0;
  59 }
  60
  61 void setup_machinename(char *machine_out)
  62 {
  63         struct utsname host;
  64
  65         uname(&host);
  66 #ifdef UML_CONFIG_UML_X86
  67 # ifndef UML_CONFIG_64BIT
  68         if (!strcmp(host.machine, "x86_64")) {
  69                 strcpy(machine_out, "i686");
  70                 return;
  71         }
  72 # else
  73         if (!strcmp(host.machine, "i686")) {
  74                 strcpy(machine_out, "x86_64");
  75                 return;
  76         }
  77 # endif
  78 #endif
  79         strcpy(machine_out, host.machine);
  80 }
  81
  82 void setup_hostinfo(char *buf, int len)
  83 {
  84         struct utsname host;
  85
  86         uname(&host);
  87         snprintf(buf, len, "%s %s %s %s %s", host.sysname, host.nodename,
  88                  host.release, host.version, host.machine);
  89 }
  90
  91 int setjmp_wrapper(void (*proc)(void *, void *), ...)
  92 {
  93         va_list args;
  94         jmp_buf buf;
  95         int n;
  96
  97         n = UML_SETJMP(&buf);
  98         if(n == 0){
  99                 va_start(args, proc);
 100                 (*proc)(&buf, &args);
 101         }
 102         va_end(args);
 103         return n;
 104 }
 105
 106 void os_dump_core(void)
 107 {
 108         int pid;
 109
 110         signal(SIGSEGV, SIG_DFL);
 111
 112         /*
 113          * We are about to SIGTERM this entire process group to ensure that
 114          * nothing is around to run after the kernel exits.  The
 115          * kernel wants to abort, not die through SIGTERM, so we
 116          * ignore it here.
 117          */
 118
 119         signal(SIGTERM, SIG_IGN);
 120         kill(0, SIGTERM);
 121         /*
 122          * Most of the other processes associated with this UML are
 123          * likely sTopped, so give them a SIGCONT so they see the
 124          * SIGTERM.
 125          */
 126         kill(0, SIGCONT);
 127
 128         /*
 129          * Now, having sent signals to everyone but us, make sure they
 130          * die by ptrace.  Processes can survive what's been done to
 131          * them so far - the mechanism I understand is receiving a
 132          * SIGSEGV and segfaulting immediately upon return.  There is
 133          * always a SIGSEGV pending, and (I'm guessing) signals are
 134          * processed in numeric order so the SIGTERM (signal 15 vs
 135          * SIGSEGV being signal 11) is never handled.
 136          *
 137          * Run a waitpid loop until we get some kind of error.
 138          * Hopefully, it's ECHILD, but there's not a lot we can do if
 139          * it's something else.  Tell os_kill_ptraced_process not to
 140          * wait for the child to report its death because there's
 141          * nothing reasonable to do if that fails.
 142          */
 143
 144         while ((pid = waitpid(-1, NULL, WNOHANG | __WALL)) > 0)
 145                 os_kill_ptraced_process(pid, 0);
 146
 147         abort();
 148 }