process.c 6.3 KB

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