um/os-Linux/process.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (C) 2015 Thomas Meyer (thomas@m3y3r.de)
0004  * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
0005  */
0006
0007 #include <stdio.h>
0008 #include <stdlib.h>
0009 #include <unistd.h>
0010 #include <errno.h>
0011 #include <signal.h>
0012 #include <fcntl.h>
0013 #include <sys/mman.h>
0014 #include <sys/ptrace.h>
0015 #include <sys/wait.h>
0016 #include <asm/unistd.h>
0017 #include <init.h>
0018 #include <longjmp.h>
0019 #include <os.h>
0020
0021 #define ARBITRARY_ADDR -1
0022 #define FAILURE_PID    -1
0023
0024 #define STAT_PATH_LEN sizeof("/proc/#######/stat\0")
0025 #define COMM_SCANF "%*[^)])"
0026
0027 unsigned long os_process_pc(int pid)
0028 {
0029     char proc_stat[STAT_PATH_LEN], buf[256];
0030     unsigned long pc = ARBITRARY_ADDR;
0031     int fd, err;
0032
0033     sprintf(proc_stat, "/proc/%d/stat", pid);
0034     fd = open(proc_stat, O_RDONLY, 0);
0035     if (fd < 0) {
0036         printk(UM_KERN_ERR "os_process_pc - couldn't open '%s', "
0037                "errno = %d\n", proc_stat, errno);
0038         goto out;
0039     }
0040     CATCH_EINTR(err = read(fd, buf, sizeof(buf)));
0041     if (err < 0) {
0042         printk(UM_KERN_ERR "os_process_pc - couldn't read '%s', "
0043                "err = %d\n", proc_stat, errno);
0044         goto out_close;
0045     }
0046     os_close_file(fd);
0047     pc = ARBITRARY_ADDR;
0048     if (sscanf(buf, "%*d " COMM_SCANF " %*c %*d %*d %*d %*d %*d %*d %*d "
0049            "%*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d "
0050            "%*d %*d %*d %*d %*d %lu", &pc) != 1)
0051         printk(UM_KERN_ERR "os_process_pc - couldn't find pc in '%s'\n",
0052                buf);
0053  out_close:
0054     close(fd);
0055  out:
0056     return pc;
0057 }
0058
0059 int os_process_parent(int pid)
0060 {
0061     char stat[STAT_PATH_LEN];
0062     char data[256];
0063     int parent = FAILURE_PID, n, fd;
0064
0065     if (pid == -1)
0066         return parent;
0067
0068     snprintf(stat, sizeof(stat), "/proc/%d/stat", pid);
0069     fd = open(stat, O_RDONLY, 0);
0070     if (fd < 0) {
0071         printk(UM_KERN_ERR "Couldn't open '%s', errno = %d\n", stat,
0072                errno);
0073         return parent;
0074     }
0075
0076     CATCH_EINTR(n = read(fd, data, sizeof(data)));
0077     close(fd);
0078
0079     if (n < 0) {
0080         printk(UM_KERN_ERR "Couldn't read '%s', errno = %d\n", stat,
0081                errno);
0082         return parent;
0083     }
0084
0085     parent = FAILURE_PID;
0086     n = sscanf(data, "%*d " COMM_SCANF " %*c %d", &parent);
0087     if (n != 1)
0088         printk(UM_KERN_ERR "Failed to scan '%s'\n", data);
0089
0090     return parent;
0091 }
0092
0093 void os_alarm_process(int pid)
0094 {
0095     kill(pid, SIGALRM);
0096 }
0097
0098 void os_stop_process(int pid)
0099 {
0100     kill(pid, SIGSTOP);
0101 }
0102
0103 void os_kill_process(int pid, int reap_child)
0104 {
0105     kill(pid, SIGKILL);
0106     if (reap_child)
0107         CATCH_EINTR(waitpid(pid, NULL, __WALL));
0108 }
0109
0110 /* Kill off a ptraced child by all means available.  kill it normally first,
0111  * then PTRACE_KILL it, then PTRACE_CONT it in case it's in a run state from
0112  * which it can't exit directly.
0113  */
0114
0115 void os_kill_ptraced_process(int pid, int reap_child)
0116 {
0117     kill(pid, SIGKILL);
0118     ptrace(PTRACE_KILL, pid);
0119     ptrace(PTRACE_CONT, pid);
0120     if (reap_child)
0121         CATCH_EINTR(waitpid(pid, NULL, __WALL));
0122 }
0123
0124 /* Don't use the glibc version, which caches the result in TLS. It misses some
0125  * syscalls, and also breaks with clone(), which does not unshare the TLS.
0126  */
0127
0128 int os_getpid(void)
0129 {
0130     return syscall(__NR_getpid);
0131 }
0132
0133 int os_getpgrp(void)
0134 {
0135     return getpgrp();
0136 }
0137
0138 int os_map_memory(void *virt, int fd, unsigned long long off, unsigned long len,
0139           int r, int w, int x)
0140 {
0141     void *loc;
0142     int prot;
0143
0144     prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
0145         (x ? PROT_EXEC : 0);
0146
0147     loc = mmap64((void *) virt, len, prot, MAP_SHARED | MAP_FIXED,
0148              fd, off);
0149     if (loc == MAP_FAILED)
0150         return -errno;
0151     return 0;
0152 }
0153
0154 int os_protect_memory(void *addr, unsigned long len, int r, int w, int x)
0155 {
0156     int prot = ((r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
0157             (x ? PROT_EXEC : 0));
0158
0159     if (mprotect(addr, len, prot) < 0)
0160         return -errno;
0161
0162     return 0;
0163 }
0164
0165 int os_unmap_memory(void *addr, int len)
0166 {
0167     int err;
0168
0169     err = munmap(addr, len);
0170     if (err < 0)
0171         return -errno;
0172     return 0;
0173 }
0174
0175 #ifndef MADV_REMOVE
0176 #define MADV_REMOVE KERNEL_MADV_REMOVE
0177 #endif
0178
0179 int os_drop_memory(void *addr, int length)
0180 {
0181     int err;
0182
0183     err = madvise(addr, length, MADV_REMOVE);
0184     if (err < 0)
0185         err = -errno;
0186     return err;
0187 }
0188
0189 int __init can_drop_memory(void)
0190 {
0191     void *addr;
0192     int fd, ok = 0;
0193
0194     printk(UM_KERN_INFO "Checking host MADV_REMOVE support...");
0195     fd = create_mem_file(UM_KERN_PAGE_SIZE);
0196     if (fd < 0) {
0197         printk(UM_KERN_ERR "Creating test memory file failed, "
0198                "err = %d\n", -fd);
0199         goto out;
0200     }
0201
0202     addr = mmap64(NULL, UM_KERN_PAGE_SIZE, PROT_READ | PROT_WRITE,
0203               MAP_SHARED, fd, 0);
0204     if (addr == MAP_FAILED) {
0205         printk(UM_KERN_ERR "Mapping test memory file failed, "
0206                "err = %d\n", -errno);
0207         goto out_close;
0208     }
0209
0210     if (madvise(addr, UM_KERN_PAGE_SIZE, MADV_REMOVE) != 0) {
0211         printk(UM_KERN_ERR "MADV_REMOVE failed, err = %d\n", -errno);
0212         goto out_unmap;
0213     }
0214
0215     printk(UM_KERN_CONT "OK\n");
0216     ok = 1;
0217
0218 out_unmap:
0219     munmap(addr, UM_KERN_PAGE_SIZE);
0220 out_close:
0221     close(fd);
0222 out:
0223     return ok;
0224 }
0225
0226 static int os_page_mincore(void *addr)
0227 {
0228     char vec[2];
0229     int ret;
0230
0231     ret = mincore(addr, UM_KERN_PAGE_SIZE, vec);
0232     if (ret < 0) {
0233         if (errno == ENOMEM || errno == EINVAL)
0234             return 0;
0235         else
0236             return -errno;
0237     }
0238
0239     return vec[0] & 1;
0240 }
0241
0242 int os_mincore(void *addr, unsigned long len)
0243 {
0244     char *vec;
0245     int ret, i;
0246
0247     if (len <= UM_KERN_PAGE_SIZE)
0248         return os_page_mincore(addr);
0249
0250     vec = calloc(1, (len + UM_KERN_PAGE_SIZE - 1) / UM_KERN_PAGE_SIZE);
0251     if (!vec)
0252         return -ENOMEM;
0253
0254     ret = mincore(addr, UM_KERN_PAGE_SIZE, vec);
0255     if (ret < 0) {
0256         if (errno == ENOMEM || errno == EINVAL)
0257             ret = 0;
0258         else
0259             ret = -errno;
0260
0261         goto out;
0262     }
0263
0264     for (i = 0; i < ((len + UM_KERN_PAGE_SIZE - 1) / UM_KERN_PAGE_SIZE); i++) {
0265         if (!(vec[i] & 1)) {
0266             ret = 0;
0267             goto out;
0268         }
0269     }
0270
0271     ret = 1;
0272 out:
0273     free(vec);
0274     return ret;
0275 }
0276
0277 void init_new_thread_signals(void)
0278 {
0279     set_handler(SIGSEGV);
0280     set_handler(SIGTRAP);
0281     set_handler(SIGFPE);
0282     set_handler(SIGILL);
0283     set_handler(SIGBUS);
0284     signal(SIGHUP, SIG_IGN);
0285     set_handler(SIGIO);
0286     signal(SIGWINCH, SIG_IGN);
0287 }