arch/um/os-Linux/process.c

   1 /*
   2  * Copyright (C) 2015 Thomas Meyer (thomas@m3y3r.de)
   3  * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
   4  * Licensed under the GPL
   5  */
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <unistd.h>
  10 #include <errno.h>
  11 #include <signal.h>
  12 #include <fcntl.h>
  13 #include <sys/mman.h>
  14 #include <sys/ptrace.h>
  15 #include <sys/wait.h>
  16 #include <asm/unistd.h>
  17 #include <init.h>
  18 #include <longjmp.h>
  19 #include <os.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_alarm_process(int pid)
  94 {
  95         kill(pid, SIGALRM);
  96 }
  97
  98 void os_stop_process(int pid)
  99 {
 100         kill(pid, SIGSTOP);
 101 }
 102
 103 void os_kill_process(int pid, int reap_child)
 104 {
 105         kill(pid, SIGKILL);
 106         if (reap_child)
 107                 CATCH_EINTR(waitpid(pid, NULL, __WALL));
 108 }
 109
 110 /* Kill off a ptraced child by all means available.  kill it normally first,
 111  * then PTRACE_KILL it, then PTRACE_CONT it in case it's in a run state from
 112  * which it can't exit directly.
 113  */
 114
 115 void os_kill_ptraced_process(int pid, int reap_child)
 116 {
 117         kill(pid, SIGKILL);
 118         ptrace(PTRACE_KILL, pid);
 119         ptrace(PTRACE_CONT, pid);
 120         if (reap_child)
 121                 CATCH_EINTR(waitpid(pid, NULL, __WALL));
 122 }
 123
 124 /* Don't use the glibc version, which caches the result in TLS. It misses some
 125  * syscalls, and also breaks with clone(), which does not unshare the TLS.
 126  */
 127
 128 int os_getpid(void)
 129 {
 130         return syscall(__NR_getpid);
 131 }
 132
 133 int os_getpgrp(void)
 134 {
 135         return getpgrp();
 136 }
 137
 138 int os_map_memory(void *virt, int fd, unsigned long long off, unsigned long len,
 139                   int r, int w, int x)
 140 {
 141         void *loc;
 142         int prot;
 143
 144         prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
 145                 (x ? PROT_EXEC : 0);
 146
 147         loc = mmap64((void *) virt, len, prot, MAP_SHARED | MAP_FIXED,
 148                      fd, off);
 149         if (loc == MAP_FAILED)
 150                 return -errno;
 151         return 0;
 152 }
 153
 154 int os_protect_memory(void *addr, unsigned long len, int r, int w, int x)
 155 {
 156         int prot = ((r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
 157                     (x ? PROT_EXEC : 0));
 158
 159         if (mprotect(addr, len, prot) < 0)
 160                 return -errno;
 161
 162         return 0;
 163 }
 164
 165 int os_unmap_memory(void *addr, int len)
 166 {
 167         int err;
 168
 169         err = munmap(addr, len);
 170         if (err < 0)
 171                 return -errno;
 172         return 0;
 173 }
 174
 175 #ifndef MADV_REMOVE
 176 #define MADV_REMOVE KERNEL_MADV_REMOVE
 177 #endif
 178
 179 int os_drop_memory(void *addr, int length)
 180 {
 181         int err;
 182
 183         err = madvise(addr, length, MADV_REMOVE);
 184         if (err < 0)
 185                 err = -errno;
 186         return err;
 187 }
 188
 189 int __init can_drop_memory(void)
 190 {
 191         void *addr;
 192         int fd, ok = 0;
 193
 194         printk(UM_KERN_INFO "Checking host MADV_REMOVE support...");
 195         fd = create_mem_file(UM_KERN_PAGE_SIZE);
 196         if (fd < 0) {
 197                 printk(UM_KERN_ERR "Creating test memory file failed, "
 198                        "err = %d\n", -fd);
 199                 goto out;
 200         }
 201
 202         addr = mmap64(NULL, UM_KERN_PAGE_SIZE, PROT_READ | PROT_WRITE,
 203                       MAP_SHARED, fd, 0);
 204         if (addr == MAP_FAILED) {
 205                 printk(UM_KERN_ERR "Mapping test memory file failed, "
 206                        "err = %d\n", -errno);
 207                 goto out_close;
 208         }
 209
 210         if (madvise(addr, UM_KERN_PAGE_SIZE, MADV_REMOVE) != 0) {
 211                 printk(UM_KERN_ERR "MADV_REMOVE failed, err = %d\n", -errno);
 212                 goto out_unmap;
 213         }
 214
 215         printk(UM_KERN_CONT "OK\n");
 216         ok = 1;
 217
 218 out_unmap:
 219         munmap(addr, UM_KERN_PAGE_SIZE);
 220 out_close:
 221         close(fd);
 222 out:
 223         return ok;
 224 }
 225
 226 static int os_page_mincore(void *addr)
 227 {
 228         char vec[2];
 229         int ret;
 230
 231         ret = mincore(addr, UM_KERN_PAGE_SIZE, vec);
 232         if (ret < 0) {
 233                 if (errno == ENOMEM || errno == EINVAL)
 234                         return 0;
 235                 else
 236                         return -errno;
 237         }
 238
 239         return vec[0] & 1;
 240 }
 241
 242 int os_mincore(void *addr, unsigned long len)
 243 {
 244         char *vec;
 245         int ret, i;
 246
 247         if (len <= UM_KERN_PAGE_SIZE)
 248                 return os_page_mincore(addr);
 249
 250         vec = calloc(1, (len + UM_KERN_PAGE_SIZE - 1) / UM_KERN_PAGE_SIZE);
 251         if (!vec)
 252                 return -ENOMEM;
 253
 254         ret = mincore(addr, UM_KERN_PAGE_SIZE, vec);
 255         if (ret < 0) {
 256                 if (errno == ENOMEM || errno == EINVAL)
 257                         ret = 0;
 258                 else
 259                         ret = -errno;
 260
 261                 goto out;
 262         }
 263
 264         for (i = 0; i < ((len + UM_KERN_PAGE_SIZE - 1) / UM_KERN_PAGE_SIZE); i++) {
 265                 if (!(vec[i] & 1)) {
 266                         ret = 0;
 267                         goto out;
 268                 }
 269         }
 270
 271         ret = 1;
 272 out:
 273         free(vec);
 274         return ret;
 275 }
 276
 277 void init_new_thread_signals(void)
 278 {
 279         set_handler(SIGSEGV);
 280         set_handler(SIGTRAP);
 281         set_handler(SIGFPE);
 282         set_handler(SIGILL);
 283         set_handler(SIGBUS);
 284         signal(SIGHUP, SIG_IGN);
 285         set_handler(SIGIO);
 286         signal(SIGWINCH, SIG_IGN);
 287 }