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 return 0; 42} 43 44void 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 65void 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 74void 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} 117