Commit | Line | Data |
---|---|---|
f45d9fc9 | 1 | /* |
1da177e4 LT |
2 | * Copyright (C) 2002 Jeff Dike (jdike@karaya.com) |
3 | * Licensed under the GPL | |
4 | */ | |
5 | ||
d67b569f | 6 | #include <signal.h> |
1da177e4 | 7 | #include <errno.h> |
07bf731e | 8 | #include <string.h> |
a61f334f | 9 | #include <unistd.h> |
1da177e4 | 10 | #include <sys/mman.h> |
d67b569f JD |
11 | #include <sys/wait.h> |
12 | #include <asm/page.h> | |
13 | #include <asm/unistd.h> | |
1da177e4 LT |
14 | #include "mem_user.h" |
15 | #include "mem.h" | |
07bf731e | 16 | #include "skas.h" |
1da177e4 LT |
17 | #include "user.h" |
18 | #include "os.h" | |
19 | #include "proc_mm.h" | |
d67b569f | 20 | #include "ptrace_user.h" |
d67b569f JD |
21 | #include "kern_util.h" |
22 | #include "task.h" | |
23 | #include "registers.h" | |
24 | #include "uml-config.h" | |
25 | #include "sysdep/ptrace.h" | |
26 | #include "sysdep/stub.h" | |
d67b569f | 27 | |
07bf731e | 28 | extern unsigned long batch_syscall_stub, __syscall_stub_start; |
d67b569f JD |
29 | |
30 | extern void wait_stub_done(int pid, int sig, char * fname); | |
31 | ||
07bf731e BS |
32 | static inline unsigned long *check_init_stack(struct mm_id * mm_idp, |
33 | unsigned long *stack) | |
34 | { | |
f45d9fc9 | 35 | if(stack == NULL) { |
07bf731e BS |
36 | stack = (unsigned long *) mm_idp->stack + 2; |
37 | *stack = 0; | |
38 | } | |
39 | return stack; | |
40 | } | |
41 | ||
42 | extern int proc_mm; | |
43 | ||
c5600490 | 44 | int single_count = 0; |
07bf731e BS |
45 | int multi_count = 0; |
46 | int multi_op_count = 0; | |
c5600490 | 47 | |
f45d9fc9 | 48 | static inline long do_syscall_stub(struct mm_id * mm_idp, void **addr) |
1da177e4 | 49 | { |
07bf731e | 50 | unsigned long regs[MAX_REG_NR]; |
b92c4f92 | 51 | int n, i; |
07bf731e | 52 | long ret, offset; |
f45d9fc9 GS |
53 | unsigned long * data; |
54 | unsigned long * syscall; | |
55 | int pid = mm_idp->u.pid; | |
07bf731e BS |
56 | |
57 | if(proc_mm) | |
58 | #warning Need to look up userspace_pid by cpu | |
59 | pid = userspace_pid[0]; | |
60 | ||
61 | multi_count++; | |
d67b569f | 62 | |
e2216feb | 63 | get_safe_registers(regs, NULL); |
f45d9fc9 | 64 | regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE + |
07bf731e | 65 | ((unsigned long) &batch_syscall_stub - |
f45d9fc9 GS |
66 | (unsigned long) &__syscall_stub_start); |
67 | ||
07bf731e | 68 | n = ptrace_setregs(pid, regs); |
b92c4f92 JD |
69 | if(n < 0){ |
70 | printk("Registers - \n"); | |
71 | for(i = 0; i < MAX_REG_NR; i++) | |
72 | printk("\t%d\t0x%lx\n", i, regs[i]); | |
07bf731e | 73 | panic("do_syscall_stub : PTRACE_SETREGS failed, errno = %d\n", |
b92c4f92 JD |
74 | -n); |
75 | } | |
07bf731e BS |
76 | |
77 | wait_stub_done(pid, 0, "do_syscall_stub"); | |
78 | ||
79 | /* When the stub stops, we find the following values on the | |
80 | * beginning of the stack: | |
81 | * (long )return_value | |
82 | * (long )offset to failed sycall-data (0, if no error) | |
83 | */ | |
84 | ret = *((unsigned long *) mm_idp->stack); | |
85 | offset = *((unsigned long *) mm_idp->stack + 1); | |
86 | if (offset) { | |
87 | data = (unsigned long *)(mm_idp->stack + | |
88 | offset - UML_CONFIG_STUB_DATA); | |
802e3077 PBG |
89 | printk("do_syscall_stub : ret = %ld, offset = %ld, " |
90 | "data = %p\n", ret, offset, data); | |
07bf731e BS |
91 | syscall = (unsigned long *)((unsigned long)data + data[0]); |
92 | printk("do_syscall_stub: syscall %ld failed, return value = " | |
93 | "0x%lx, expected return value = 0x%lx\n", | |
94 | syscall[0], ret, syscall[7]); | |
95 | printk(" syscall parameters: " | |
96 | "0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n", | |
97 | syscall[1], syscall[2], syscall[3], | |
98 | syscall[4], syscall[5], syscall[6]); | |
99 | for(n = 1; n < data[0]/sizeof(long); n++) { | |
100 | if(n == 1) | |
101 | printk(" additional syscall data:"); | |
102 | if(n % 4 == 1) | |
103 | printk("\n "); | |
104 | printk(" 0x%lx", data[n]); | |
105 | } | |
106 | if(n > 1) | |
107 | printk("\n"); | |
c5600490 | 108 | } |
07bf731e | 109 | else ret = 0; |
c5600490 | 110 | |
07bf731e | 111 | *addr = check_init_stack(mm_idp, NULL); |
c5600490 | 112 | |
07bf731e | 113 | return ret; |
c5600490 JD |
114 | } |
115 | ||
07bf731e BS |
116 | long run_syscall_stub(struct mm_id * mm_idp, int syscall, |
117 | unsigned long *args, long expected, void **addr, | |
f45d9fc9 | 118 | int done) |
c5600490 | 119 | { |
f45d9fc9 | 120 | unsigned long *stack = check_init_stack(mm_idp, *addr); |
07bf731e BS |
121 | |
122 | if(done && *addr == NULL) | |
123 | single_count++; | |
124 | ||
f45d9fc9 | 125 | *stack += sizeof(long); |
07bf731e | 126 | stack += *stack / sizeof(long); |
c5600490 | 127 | |
f45d9fc9 GS |
128 | *stack++ = syscall; |
129 | *stack++ = args[0]; | |
130 | *stack++ = args[1]; | |
131 | *stack++ = args[2]; | |
132 | *stack++ = args[3]; | |
133 | *stack++ = args[4]; | |
134 | *stack++ = args[5]; | |
07bf731e | 135 | *stack++ = expected; |
f45d9fc9 GS |
136 | *stack = 0; |
137 | multi_op_count++; | |
c5600490 | 138 | |
f45d9fc9 | 139 | if(!done && ((((unsigned long) stack) & ~PAGE_MASK) < |
07bf731e BS |
140 | PAGE_SIZE - 10 * sizeof(long))){ |
141 | *addr = stack; | |
f45d9fc9 GS |
142 | return 0; |
143 | } | |
c5600490 | 144 | |
07bf731e BS |
145 | return do_syscall_stub(mm_idp, addr); |
146 | } | |
c5600490 | 147 | |
07bf731e BS |
148 | long syscall_stub_data(struct mm_id * mm_idp, |
149 | unsigned long *data, int data_count, | |
150 | void **addr, void **stub_addr) | |
151 | { | |
152 | unsigned long *stack; | |
153 | int ret = 0; | |
154 | ||
155 | /* If *addr still is uninitialized, it *must* contain NULL. | |
156 | * Thus in this case do_syscall_stub correctly won't be called. | |
157 | */ | |
158 | if((((unsigned long) *addr) & ~PAGE_MASK) >= | |
159 | PAGE_SIZE - (10 + data_count) * sizeof(long)) { | |
160 | ret = do_syscall_stub(mm_idp, addr); | |
f45d9fc9 | 161 | /* in case of error, don't overwrite data on stack */ |
07bf731e BS |
162 | if(ret) |
163 | return ret; | |
164 | } | |
d67b569f | 165 | |
07bf731e BS |
166 | stack = check_init_stack(mm_idp, *addr); |
167 | *addr = stack; | |
d67b569f | 168 | |
07bf731e | 169 | *stack = data_count * sizeof(long); |
1da177e4 | 170 | |
07bf731e | 171 | memcpy(stack + 1, data, data_count * sizeof(long)); |
c5600490 | 172 | |
07bf731e BS |
173 | *stub_addr = (void *)(((unsigned long)(stack + 1) & ~PAGE_MASK) + |
174 | UML_CONFIG_STUB_DATA); | |
c5600490 | 175 | |
07bf731e | 176 | return 0; |
c5600490 JD |
177 | } |
178 | ||
07bf731e BS |
179 | int map(struct mm_id * mm_idp, unsigned long virt, unsigned long len, |
180 | int r, int w, int x, int phys_fd, unsigned long long offset, | |
181 | int done, void **data) | |
1da177e4 | 182 | { |
f45d9fc9 GS |
183 | int prot, ret; |
184 | ||
185 | prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | | |
186 | (x ? PROT_EXEC : 0); | |
187 | ||
188 | if(proc_mm){ | |
189 | struct proc_mm_op map; | |
190 | int fd = mm_idp->u.mm_fd; | |
191 | ||
192 | map = ((struct proc_mm_op) { .op = MM_MMAP, | |
193 | .u = | |
194 | { .mmap = | |
195 | { .addr = virt, | |
196 | .len = len, | |
197 | .prot = prot, | |
198 | .flags = MAP_SHARED | | |
199 | MAP_FIXED, | |
200 | .fd = phys_fd, | |
201 | .offset= offset | |
202 | } } } ); | |
a61f334f JD |
203 | CATCH_EINTR(ret = write(fd, &map, sizeof(map))); |
204 | if(ret != sizeof(map)){ | |
205 | ret = -errno; | |
07bf731e | 206 | printk("map : /proc/mm map failed, err = %d\n", -ret); |
a61f334f | 207 | } |
07bf731e | 208 | else ret = 0; |
f45d9fc9 GS |
209 | } |
210 | else { | |
211 | unsigned long args[] = { virt, len, prot, | |
212 | MAP_SHARED | MAP_FIXED, phys_fd, | |
213 | MMAP_OFFSET(offset) }; | |
d67b569f | 214 | |
07bf731e BS |
215 | ret = run_syscall_stub(mm_idp, STUB_MMAP_NR, args, virt, |
216 | data, done); | |
f45d9fc9 | 217 | } |
d67b569f | 218 | |
07bf731e | 219 | return ret; |
1da177e4 LT |
220 | } |
221 | ||
07bf731e BS |
222 | int unmap(struct mm_id * mm_idp, void *addr, unsigned long len, int done, |
223 | void **data) | |
1da177e4 | 224 | { |
f45d9fc9 GS |
225 | int ret; |
226 | ||
227 | if(proc_mm){ | |
228 | struct proc_mm_op unmap; | |
229 | int fd = mm_idp->u.mm_fd; | |
230 | ||
231 | unmap = ((struct proc_mm_op) { .op = MM_MUNMAP, | |
232 | .u = | |
233 | { .munmap = | |
234 | { .addr = | |
235 | (unsigned long) addr, | |
236 | .len = len } } } ); | |
a61f334f JD |
237 | CATCH_EINTR(ret = write(fd, &unmap, sizeof(unmap))); |
238 | if(ret != sizeof(unmap)){ | |
239 | ret = -errno; | |
07bf731e | 240 | printk("unmap - proc_mm write returned %d\n", ret); |
a61f334f | 241 | } |
07bf731e | 242 | else ret = 0; |
f45d9fc9 GS |
243 | } |
244 | else { | |
245 | unsigned long args[] = { (unsigned long) addr, len, 0, 0, 0, | |
246 | 0 }; | |
d67b569f | 247 | |
07bf731e BS |
248 | ret = run_syscall_stub(mm_idp, __NR_munmap, args, 0, |
249 | data, done); | |
f45d9fc9 | 250 | } |
d67b569f | 251 | |
f45d9fc9 | 252 | return ret; |
d67b569f | 253 | } |
1da177e4 | 254 | |
07bf731e BS |
255 | int protect(struct mm_id * mm_idp, unsigned long addr, unsigned long len, |
256 | int r, int w, int x, int done, void **data) | |
d67b569f | 257 | { |
f45d9fc9 GS |
258 | struct proc_mm_op protect; |
259 | int prot, ret; | |
260 | ||
261 | prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | | |
262 | (x ? PROT_EXEC : 0); | |
263 | if(proc_mm){ | |
264 | int fd = mm_idp->u.mm_fd; | |
265 | ||
266 | protect = ((struct proc_mm_op) { .op = MM_MPROTECT, | |
267 | .u = | |
268 | { .mprotect = | |
269 | { .addr = | |
270 | (unsigned long) addr, | |
271 | .len = len, | |
272 | .prot = prot } } } ); | |
273 | ||
a61f334f JD |
274 | CATCH_EINTR(ret = write(fd, &protect, sizeof(protect))); |
275 | if(ret != sizeof(protect)){ | |
276 | ret = -errno; | |
f45d9fc9 | 277 | printk("protect failed, err = %d", -ret); |
a61f334f | 278 | } |
f45d9fc9 GS |
279 | else ret = 0; |
280 | } | |
281 | else { | |
282 | unsigned long args[] = { addr, len, prot, 0, 0, 0 }; | |
283 | ||
284 | ret = run_syscall_stub(mm_idp, __NR_mprotect, args, 0, | |
285 | data, done); | |
286 | } | |
287 | ||
288 | return ret; | |
1da177e4 LT |
289 | } |
290 | ||
291 | void before_mem_skas(unsigned long unused) | |
292 | { | |
293 | } |