Auto merge with /home/aegl/GIT/linus
[linux-2.6] / arch / um / os-Linux / process.c
1 /* 
2  * Copyright (C) 2002 Jeff Dike (jdike@addtoit.com)
3  * Licensed under the GPL
4  */
5
6 #include <unistd.h>
7 #include <stdio.h>
8 #include <errno.h>
9 #include <signal.h>
10 #include <linux/unistd.h>
11 #include <sys/mman.h>
12 #include <sys/wait.h>
13 #include "ptrace_user.h"
14 #include "os.h"
15 #include "user.h"
16 #include "user_util.h"
17
18 #define ARBITRARY_ADDR -1
19 #define FAILURE_PID    -1
20
21 #define STAT_PATH_LEN sizeof("/proc/#######/stat\0")
22 #define COMM_SCANF "%*[^)])"
23
24 unsigned long os_process_pc(int pid)
25 {
26         char proc_stat[STAT_PATH_LEN], buf[256];
27         unsigned long pc;
28         int fd, err;
29
30         sprintf(proc_stat, "/proc/%d/stat", pid);
31         fd = os_open_file(proc_stat, of_read(OPENFLAGS()), 0);
32         if(fd < 0){
33                 printk("os_process_pc - couldn't open '%s', err = %d\n",
34                        proc_stat, -fd);
35                 return(ARBITRARY_ADDR);
36         }
37         err = os_read_file(fd, buf, sizeof(buf));
38         if(err < 0){
39                 printk("os_process_pc - couldn't read '%s', err = %d\n",
40                        proc_stat, -err);
41                 os_close_file(fd);
42                 return(ARBITRARY_ADDR);
43         }
44         os_close_file(fd);
45         pc = ARBITRARY_ADDR;
46         if(sscanf(buf, "%*d " COMM_SCANF " %*c %*d %*d %*d %*d %*d %*d %*d "
47                   "%*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d "
48                   "%*d %*d %*d %*d %*d %lu", &pc) != 1){
49                 printk("os_process_pc - couldn't find pc in '%s'\n", buf);
50         }
51         return(pc);
52 }
53
54 int os_process_parent(int pid)
55 {
56         char stat[STAT_PATH_LEN];
57         char data[256];
58         int parent, n, fd;
59
60         if(pid == -1) return(-1);
61
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
69         n = os_read_file(fd, data, sizeof(data));
70         os_close_file(fd);
71
72         if(n < 0){
73                 printk("Couldn't read '%s', err = %d\n", stat, -n);
74                 return(FAILURE_PID);
75         }
76
77         parent = FAILURE_PID;
78         n = sscanf(data, "%*d " COMM_SCANF " %*c %d", &parent);
79         if(n != 1)
80                 printk("Failed to scan '%s'\n", data);
81
82         return(parent);
83 }
84
85 void os_stop_process(int pid)
86 {
87         kill(pid, SIGSTOP);
88 }
89
90 void os_kill_process(int pid, int reap_child)
91 {
92         kill(pid, SIGKILL);
93         if(reap_child)
94                 CATCH_EINTR(waitpid(pid, NULL, 0));
95                 
96 }
97
98 /* Kill off a ptraced child by all means available.  kill it normally first,
99  * then PTRACE_KILL it, then PTRACE_CONT it in case it's in a run state from
100  * which it can't exit directly.
101  */
102
103 void os_kill_ptraced_process(int pid, int reap_child)
104 {
105         kill(pid, SIGKILL);
106         ptrace(PTRACE_KILL, pid);
107         ptrace(PTRACE_CONT, pid);
108         if(reap_child)
109                 CATCH_EINTR(waitpid(pid, NULL, 0));
110 }
111
112 void os_usr1_process(int pid)
113 {
114         kill(pid, SIGUSR1);
115 }
116
117 /*Don't use the glibc version, which caches the result in TLS. It misses some
118  * syscalls, and also breaks with clone(), which does not unshare the TLS.*/
119 inline _syscall0(pid_t, getpid)
120
121 int os_getpid(void)
122 {
123         return(getpid());
124 }
125
126 int os_getpgrp(void)
127 {
128         return getpgrp();
129 }
130
131 int os_map_memory(void *virt, int fd, unsigned long long off, unsigned long len,
132                   int r, int w, int x)
133 {
134         void *loc;
135         int prot;
136
137         prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | 
138                 (x ? PROT_EXEC : 0);
139
140         loc = mmap64((void *) virt, len, prot, MAP_SHARED | MAP_FIXED,
141                      fd, off);
142         if(loc == MAP_FAILED)
143                 return(-errno);
144         return(0);
145 }
146
147 int os_protect_memory(void *addr, unsigned long len, int r, int w, int x)
148 {
149         int prot = ((r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | 
150                     (x ? PROT_EXEC : 0));
151
152         if(mprotect(addr, len, prot) < 0)
153                 return(-errno);
154         return(0);
155 }
156
157 int os_unmap_memory(void *addr, int len)
158 {
159         int err;
160
161         err = munmap(addr, len);
162         if(err < 0)
163                 return(-errno);
164         return(0);
165 }
166
167 /*
168  * Overrides for Emacs so that we follow Linus's tabbing style.
169  * Emacs will notice this stuff at the end of the file and automatically
170  * adjust the settings for this buffer only.  This must remain at the end
171  * of the file.
172  * ---------------------------------------------------------------------------
173  * Local variables:
174  * c-file-style: "linux"
175  * End:
176  */