LXR linux/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
  19void 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
  26int 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        /*
  42         * XXX tcsetattr could have applied only some changes
  43         * (and cfmakeraw() is a set of changes)
  44         */
  45        return 0;
  46}
  47
  48void setup_machinename(char *machine_out)
  49{
  50        struct utsname host;
  51
  52        uname(&host);
  53#ifdef UML_CONFIG_UML_X86
  54# ifndef UML_CONFIG_64BIT
  55        if (!strcmp(host.machine, "x86_64")) {
  56                strcpy(machine_out, "i686");
  57                return;
  58        }
  59# else
  60        if (!strcmp(host.machine, "i686")) {
  61                strcpy(machine_out, "x86_64");
  62                return;
  63        }
  64# endif
  65#endif
  66        strcpy(machine_out, host.machine);
  67}
  68
  69void setup_hostinfo(char *buf, int len)
  70{
  71        struct utsname host;
  72
  73        uname(&host);
  74        snprintf(buf, len, "%s %s %s %s %s", host.sysname, host.nodename,
  75                 host.release, host.version, host.machine);
  76}
  77
  78void os_dump_core(void)
  79{
  80        int pid;
  81
  82        signal(SIGSEGV, SIG_DFL);
  83
  84        /*
  85         * We are about to SIGTERM this entire process group to ensure that
  86         * nothing is around to run after the kernel exits.  The
  87         * kernel wants to abort, not die through SIGTERM, so we
  88         * ignore it here.
  89         */
  90
  91        signal(SIGTERM, SIG_IGN);
  92        kill(0, SIGTERM);
  93        /*
  94         * Most of the other processes associated with this UML are
  95         * likely sTopped, so give them a SIGCONT so they see the
  96         * SIGTERM.
  97         */
  98        kill(0, SIGCONT);
  99
 100        /*
 101         * Now, having sent signals to everyone but us, make sure they
 102         * die by ptrace.  Processes can survive what's been done to
 103         * them so far - the mechanism I understand is receiving a
 104         * SIGSEGV and segfaulting immediately upon return.  There is
 105         * always a SIGSEGV pending, and (I'm guessing) signals are
 106         * processed in numeric order so the SIGTERM (signal 15 vs
 107         * SIGSEGV being signal 11) is never handled.
 108         *
 109         * Run a waitpid loop until we get some kind of error.
 110         * Hopefully, it's ECHILD, but there's not a lot we can do if
 111         * it's something else.  Tell os_kill_ptraced_process not to
 112         * wait for the child to report its death because there's
 113         * nothing reasonable to do if that fails.
 114         */
 115
 116        while ((pid = waitpid(-1, NULL, WNOHANG | __WALL)) > 0)
 117                os_kill_ptraced_process(pid, 0);
 118
 119        abort();
 120}
 121