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

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

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ 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.77 ] ~ [ 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) 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 }
288 

~ [ 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