~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/um/os-Linux/process.c

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp