arch/um/os-Linux/process.c

   1 /*
   2  * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
   3  * Licensed under the GPL
   4  */
   5
   6 #include <stdio.h>
   7 #include <unistd.h>
   8 #include <errno.h>
   9 #include <signal.h>
  10 #include <fcntl.h>
  11 #include <sys/mman.h>
  12 #include <sys/ptrace.h>
  13 #include <sys/wait.h>
  14 #include <asm/unistd.h>
  15 #include "init.h"
  16 #include "longjmp.h"
  17 #include "os.h"
  18 #include "process.h"
  19 #include "skas_ptrace.h"
  20
  21 #define ARBITRARY_ADDR -1
  22 #define FAILURE_PID    -1
  23
  24 #define STAT_PATH_LEN sizeof("/proc/#######/stat\0")
  25 #define COMM_SCANF "%*[^)])"
  26
  27 unsigned long os_process_pc(int pid)
  28 {
  29         char proc_stat[STAT_PATH_LEN], buf[256];
  30         unsigned long pc = ARBITRARY_ADDR;
  31         int fd, err;
  32
  33         sprintf(proc_stat, "/proc/%d/stat", pid);
  34         fd = open(proc_stat, O_RDONLY, 0);
  35         if (fd < 0) {
  36                 printk(UM_KERN_ERR "os_process_pc - couldn't open '%s', "
  37                        "errno = %d\n", proc_stat, errno);
  38                 goto out;
  39         }
  40         CATCH_EINTR(err = read(fd, buf, sizeof(buf)));
  41         if (err < 0) {
  42                 printk(UM_KERN_ERR "os_process_pc - couldn't read '%s', "
  43                        "err = %d\n", proc_stat, errno);
  44                 goto out_close;
  45         }
  46         os_close_file(fd);
  47         pc = ARBITRARY_ADDR;
  48         if (sscanf(buf, "%*d " COMM_SCANF " %*c %*d %*d %*d %*d %*d %*d %*d "
  49                    "%*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d "
  50                    "%*d %*d %*d %*d %*d %lu", &pc) != 1)
  51                 printk(UM_KERN_ERR "os_process_pc - couldn't find pc in '%s'\n",
  52                        buf);
  53  out_close:
  54         close(fd);
  55  out:
  56         return pc;
  57 }
  58
  59 int os_process_parent(int pid)
  60 {
  61         char stat[STAT_PATH_LEN];
  62         char data[256];
  63         int parent = FAILURE_PID, n, fd;
  64
  65         if (pid == -1)
  66                 return parent;
  67
  68         snprintf(stat, sizeof(stat), "/proc/%d/stat", pid);
  69         fd = open(stat, O_RDONLY, 0);
  70         if (fd < 0) {
  71                 printk(UM_KERN_ERR "Couldn't open '%s', errno = %d\n", stat,
  72                        errno);
  73                 return parent;
  74         }
  75
  76         CATCH_EINTR(n = read(fd, data, sizeof(data)));
  77         close(fd);
  78
  79         if (n < 0) {
  80                 printk(UM_KERN_ERR "Couldn't read '%s', errno = %d\n", stat,
  81                        errno);
  82                 return parent;
  83         }
  84
  85         parent = FAILURE_PID;
  86         n = sscanf(data, "%*d " COMM_SCANF " %*c %d", &parent);
  87         if (n != 1)
  88                 printk(UM_KERN_ERR "Failed to scan '%s'\n", data);
  89
  90         return parent;
  91 }
  92
  93 void os_stop_process(int pid)
  94 {
  95         kill(pid, SIGSTOP);
  96 }
  97
  98 void os_kill_process(int pid, int reap_child)
  99 {
 100         kill(pid, SIGKILL);
 101         if (reap_child)
 102                 CATCH_EINTR(waitpid(pid, NULL, __WALL));
 103 }
 104
 105 /* This is here uniquely to have access to the userspace errno, i.e. the one
 106  * used by ptrace in case of error.
 107  */
 108
 109 long os_ptrace_ldt(long pid, long addr, long data)
 110 {
 111         int ret;
 112
 113         ret = ptrace(PTRACE_LDT, pid, addr, data);
 114
 115         if (ret < 0)
 116                 return -errno;
 117         return ret;
 118 }
 119
 120 /* Kill off a ptraced child by all means available.  kill it normally first,
 121  * then PTRACE_KILL it, then PTRACE_CONT it in case it's in a run state from
 122  * which it can't exit directly.
 123  */
 124
 125 void os_kill_ptraced_process(int pid, int reap_child)
 126 {
 127         kill(pid, SIGKILL);
 128         ptrace(PTRACE_KILL, pid);
 129         ptrace(PTRACE_CONT, pid);
 130         if (reap_child)
 131                 CATCH_EINTR(waitpid(pid, NULL, __WALL));
 132 }
 133
 134 /* Don't use the glibc version, which caches the result in TLS. It misses some
 135  * syscalls, and also breaks with clone(), which does not unshare the TLS.
 136  */
 137
 138 int os_getpid(void)
 139 {
 140         return syscall(__NR_getpid);
 141 }
 142
 143 int os_getpgrp(void)
 144 {
 145         return getpgrp();
 146 }
 147
 148 int os_map_memory(void *virt, int fd, unsigned long long off, unsigned long len,
 149                   int r, int w, int x)
 150 {
 151         void *loc;
 152         int prot;
 153
 154         prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
 155                 (x ? PROT_EXEC : 0);
 156
 157         loc = mmap64((void *) virt, len, prot, MAP_SHARED | MAP_FIXED,
 158                      fd, off);
 159         if (loc == MAP_FAILED)
 160                 return -errno;
 161         return 0;
 162 }
 163
 164 int os_protect_memory(void *addr, unsigned long len, int r, int w, int x)
 165 {
 166         int prot = ((r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
 167                     (x ? PROT_EXEC : 0));
 168
 169         if (mprotect(addr, len, prot) < 0)
 170                 return -errno;
 171
 172         return 0;
 173 }
 174
 175 int os_unmap_memory(void *addr, int len)
 176 {
 177         int err;
 178
 179         err = munmap(addr, len);
 180         if (err < 0)
 181                 return -errno;
 182         return 0;
 183 }
 184
 185 #ifndef MADV_REMOVE
 186 #define MADV_REMOVE KERNEL_MADV_REMOVE
 187 #endif
 188
 189 int os_drop_memory(void *addr, int length)
 190 {
 191         int err;
 192
 193         err = madvise(addr, length, MADV_REMOVE);
 194         if (err < 0)
 195                 err = -errno;
 196         return err;
 197 }
 198
 199 int __init can_drop_memory(void)
 200 {
 201         void *addr;
 202         int fd, ok = 0;
 203
 204         printk(UM_KERN_INFO "Checking host MADV_REMOVE support...");
 205         fd = create_mem_file(UM_KERN_PAGE_SIZE);
 206         if (fd < 0) {
 207                 printk(UM_KERN_ERR "Creating test memory file failed, "
 208                        "err = %d\n", -fd);
 209                 goto out;
 210         }
 211
 212         addr = mmap64(NULL, UM_KERN_PAGE_SIZE, PROT_READ | PROT_WRITE,
 213                       MAP_SHARED, fd, 0);
 214         if (addr == MAP_FAILED) {
 215                 printk(UM_KERN_ERR "Mapping test memory file failed, "
 216                        "err = %d\n", -errno);
 217                 goto out_close;
 218         }
 219
 220         if (madvise(addr, UM_KERN_PAGE_SIZE, MADV_REMOVE) != 0) {
 221                 printk(UM_KERN_ERR "MADV_REMOVE failed, err = %d\n", -errno);
 222                 goto out_unmap;
 223         }
 224
 225         printk(UM_KERN_CONT "OK\n");
 226         ok = 1;
 227
 228 out_unmap:
 229         munmap(addr, UM_KERN_PAGE_SIZE);
 230 out_close:
 231         close(fd);
 232 out:
 233         return ok;
 234 }
 235
 236 void init_new_thread_signals(void)
 237 {
 238         set_handler(SIGSEGV);
 239         set_handler(SIGTRAP);
 240         set_handler(SIGFPE);
 241         set_handler(SIGILL);
 242         set_handler(SIGBUS);
 243         signal(SIGHUP, SIG_IGN);
 244         set_handler(SIGIO);
 245         signal(SIGWINCH, SIG_IGN);
 246         signal(SIGTERM, SIG_DFL);
 247 }
 248
 249 int run_kernel_thread(int (*fn)(void *), void *arg, jmp_buf **jmp_ptr)
 250 {
 251         jmp_buf buf;
 252         int n;
 253
 254         *jmp_ptr = &buf;
 255         n = UML_SETJMP(&buf);
 256         if (n != 0)
 257                 return n;
 258         (*fn)(arg);
 259         return 0;
 260 }