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