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 <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 <init.h>
  17#include <os.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
  78/*
  79 * We cannot use glibc's abort(). It makes use of tgkill() which
  80 * has no effect within UML's kernel threads.
  81 * After that glibc would execute an invalid instruction to kill
  82 * the calling process and UML crashes with SIGSEGV.
  83 */
  84static inline void __attribute__ ((noreturn)) uml_abort(void)
  85{
  86        sigset_t sig;
  87
  88        fflush(NULL);
  89
  90        if (!sigemptyset(&sig) && !sigaddset(&sig, SIGABRT))
  91                sigprocmask(SIG_UNBLOCK, &sig, 0);
  92
  93        for (;;)
  94                if (kill(getpid(), SIGABRT) < 0)
  95                        exit(127);
  96}
  97
  98/*
  99 * UML helper threads must not handle SIGWINCH/INT/TERM
 100 */
 101void os_fix_helper_signals(void)
 102{
 103        signal(SIGWINCH, SIG_IGN);
 104        signal(SIGINT, SIG_DFL);
 105        signal(SIGTERM, SIG_DFL);
 106}
 107
 108void os_dump_core(void)
 109{
 110        int pid;
 111
 112        signal(SIGSEGV, SIG_DFL);
 113
 114        /*
 115         * We are about to SIGTERM this entire process group to ensure that
 116         * nothing is around to run after the kernel exits.  The
 117         * kernel wants to abort, not die through SIGTERM, so we
 118         * ignore it here.
 119         */
 120
 121        signal(SIGTERM, SIG_IGN);
 122        kill(0, SIGTERM);
 123        /*
 124         * Most of the other processes associated with this UML are
 125         * likely sTopped, so give them a SIGCONT so they see the
 126         * SIGTERM.
 127         */
 128        kill(0, SIGCONT);
 129
 130        /*
 131         * Now, having sent signals to everyone but us, make sure they
 132         * die by ptrace.  Processes can survive what's been done to
 133         * them so far - the mechanism I understand is receiving a
 134         * SIGSEGV and segfaulting immediately upon return.  There is
 135         * always a SIGSEGV pending, and (I'm guessing) signals are
 136         * processed in numeric order so the SIGTERM (signal 15 vs
 137         * SIGSEGV being signal 11) is never handled.
 138         *
 139         * Run a waitpid loop until we get some kind of error.
 140         * Hopefully, it's ECHILD, but there's not a lot we can do if
 141         * it's something else.  Tell os_kill_ptraced_process not to
 142         * wait for the child to report its death because there's
 143         * nothing reasonable to do if that fails.
 144         */
 145
 146        while ((pid = waitpid(-1, NULL, WNOHANG | __WALL)) > 0)
 147                os_kill_ptraced_process(pid, 0);
 148
 149        uml_abort();
 150}
 151
 152void um_early_printk(const char *s, unsigned int n)
 153{
 154        printf("%.*s", n, s);
 155}
 156
 157static int quiet_info;
 158
 159static int __init quiet_cmd_param(char *str, int *add)
 160{
 161        quiet_info = 1;
 162        return 0;
 163}
 164
 165__uml_setup("quiet", quiet_cmd_param,
 166"quiet\n"
 167"    Turns off information messages during boot.\n\n");
 168
 169void os_info(const char *fmt, ...)
 170{
 171        va_list list;
 172
 173        if (quiet_info)
 174                return;
 175
 176        va_start(list, fmt);
 177        vfprintf(stderr, fmt, list);
 178        va_end(list);
 179}
 180
 181void os_warn(const char *fmt, ...)
 182{
 183        va_list list;
 184
 185        va_start(list, fmt);
 186        vfprintf(stderr, fmt, list);
 187        va_end(list);
 188}
 189