SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 void os_dump_core(void)
  92 {
  93         int pid;
  94
  95         signal(SIGSEGV, SIG_DFL);
  96
  97         /*
  98          * We are about to SIGTERM this entire process group to ensure that
  99          * nothing is around to run after the kernel exits.  The
 100          * kernel wants to abort, not die through SIGTERM, so we
 101          * ignore it here.
 102          */
 103
 104         signal(SIGTERM, SIG_IGN);
 105         kill(0, SIGTERM);
 106         /*
 107          * Most of the other processes associated with this UML are
 108          * likely sTopped, so give them a SIGCONT so they see the
 109          * SIGTERM.
 110          */
 111         kill(0, SIGCONT);
 112
 113         /*
 114          * Now, having sent signals to everyone but us, make sure they
 115          * die by ptrace.  Processes can survive what's been done to
 116          * them so far - the mechanism I understand is receiving a
 117          * SIGSEGV and segfaulting immediately upon return.  There is
 118          * always a SIGSEGV pending, and (I'm guessing) signals are
 119          * processed in numeric order so the SIGTERM (signal 15 vs
 120          * SIGSEGV being signal 11) is never handled.
 121          *
 122          * Run a waitpid loop until we get some kind of error.
 123          * Hopefully, it's ECHILD, but there's not a lot we can do if
 124          * it's something else.  Tell os_kill_ptraced_process not to
 125          * wait for the child to report its death because there's
 126          * nothing reasonable to do if that fails.
 127          */
 128
 129         while ((pid = waitpid(-1, NULL, WNOHANG | __WALL)) > 0)
 130                 os_kill_ptraced_process(pid, 0);
 131
 132         abort();
 133 }