release/src-rt-6.x.4708/linux/linux-2.6.36/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 <errno.h>
   9 #include <signal.h>
  10 #include <string.h>
  11 #include <termios.h>
  12 #include <wait.h>
  13 #include <sys/mman.h>
  14 #include <sys/utsname.h>
  15 #include "kern_constants.h"
  16 #include "os.h"
  17 #include "user.h"
  18
  19 void stack_protections(unsigned long address)
  20 {
  21         if (mprotect((void *) address, UM_THREAD_SIZE,
  22                     PROT_READ | PROT_WRITE | PROT_EXEC) < 0)
  23                 panic("protecting stack failed, errno = %d", errno);
  24 }
  25
  26 int raw(int fd)
  27 {
  28         struct termios tt;
  29         int err;
  30
  31         CATCH_EINTR(err = tcgetattr(fd, &tt));
  32         if (err < 0)
  33                 return -errno;
  34
  35         cfmakeraw(&tt);
  36
  37         CATCH_EINTR(err = tcsetattr(fd, TCSADRAIN, &tt));
  38         if (err < 0)
  39                 return -errno;
  40
  41         return 0;
  42 }
  43
  44 void setup_machinename(char *machine_out)
  45 {
  46         struct utsname host;
  47
  48         uname(&host);
  49 #ifdef UML_CONFIG_UML_X86
  50 # ifndef UML_CONFIG_64BIT
  51         if (!strcmp(host.machine, "x86_64")) {
  52                 strcpy(machine_out, "i686");
  53                 return;
  54         }
  55 # else
  56         if (!strcmp(host.machine, "i686")) {
  57                 strcpy(machine_out, "x86_64");
  58                 return;
  59         }
  60 # endif
  61 #endif
  62         strcpy(machine_out, host.machine);
  63 }
  64
  65 void setup_hostinfo(char *buf, int len)
  66 {
  67         struct utsname host;
  68
  69         uname(&host);
  70         snprintf(buf, len, "%s %s %s %s %s", host.sysname, host.nodename,
  71                  host.release, host.version, host.machine);
  72 }
  73
  74 void os_dump_core(void)
  75 {
  76         int pid;
  77
  78         signal(SIGSEGV, SIG_DFL);
  79
  80         /*
  81          * We are about to SIGTERM this entire process group to ensure that
  82          * nothing is around to run after the kernel exits.  The
  83          * kernel wants to abort, not die through SIGTERM, so we
  84          * ignore it here.
  85          */
  86
  87         signal(SIGTERM, SIG_IGN);
  88         kill(0, SIGTERM);
  89         /*
  90          * Most of the other processes associated with this UML are
  91          * likely sTopped, so give them a SIGCONT so they see the
  92          * SIGTERM.
  93          */
  94         kill(0, SIGCONT);
  95
  96         /*
  97          * Now, having sent signals to everyone but us, make sure they
  98          * die by ptrace.  Processes can survive what's been done to
  99          * them so far - the mechanism I understand is receiving a
 100          * SIGSEGV and segfaulting immediately upon return.  There is
 101          * always a SIGSEGV pending, and (I'm guessing) signals are
 102          * processed in numeric order so the SIGTERM (signal 15 vs
 103          * SIGSEGV being signal 11) is never handled.
 104          *
 105          * Run a waitpid loop until we get some kind of error.
 106          * Hopefully, it's ECHILD, but there's not a lot we can do if
 107          * it's something else.  Tell os_kill_ptraced_process not to
 108          * wait for the child to report its death because there's
 109          * nothing reasonable to do if that fails.
 110          */
 111
 112         while ((pid = waitpid(-1, NULL, WNOHANG | __WALL)) > 0)
 113                 os_kill_ptraced_process(pid, 0);
 114
 115         abort();
 116 }