1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include "qemu/osdep.h"
20#include "qemu/cutils.h"
21#include "qemu/path.h"
22#include <sys/syscall.h>
23#include <sys/param.h>
24#include <sys/sysctl.h>
25#include <utime.h>
26
27#include "qemu.h"
28#include "qemu-common.h"
29#include "user/syscall-trace.h"
30
31
32
33static abi_ulong target_brk;
34static abi_ulong target_original_brk;
35
36abi_long get_errno(abi_long ret)
37{
38 if (ret == -1) {
39
40 return -(errno);
41 }
42 return ret;
43}
44
45#define target_to_host_bitmask(x, tbl) (x)
46
47bool is_error(abi_long ret)
48{
49 return (abi_ulong)ret >= (abi_ulong)(-4096);
50}
51
52void target_set_brk(abi_ulong new_brk)
53{
54 target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
55}
56
57
58static abi_long do_obreak(abi_ulong new_brk)
59{
60 abi_ulong brk_page;
61 abi_long mapped_addr;
62 int new_alloc_size;
63
64 if (!new_brk)
65 return 0;
66 if (new_brk < target_original_brk)
67 return -TARGET_EINVAL;
68
69 brk_page = HOST_PAGE_ALIGN(target_brk);
70
71
72 if (new_brk < brk_page) {
73 target_brk = new_brk;
74 return 0;
75 }
76
77
78 new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page + 1);
79 mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
80 PROT_READ|PROT_WRITE,
81 MAP_ANON|MAP_FIXED|MAP_PRIVATE, -1, 0));
82
83 if (!is_error(mapped_addr))
84 target_brk = new_brk;
85 else
86 return mapped_addr;
87
88 return 0;
89}
90
91#ifdef __FreeBSD__
92
93
94
95
96
97static int
98oidfmt(int *oid, int len, char *fmt, uint32_t *kind)
99{
100 int qoid[CTL_MAXNAME+2];
101 uint8_t buf[BUFSIZ];
102 int i;
103 size_t j;
104
105 qoid[0] = 0;
106 qoid[1] = 4;
107 memcpy(qoid + 2, oid, len * sizeof(int));
108
109 j = sizeof(buf);
110 i = sysctl(qoid, len + 2, buf, &j, 0, 0);
111 if (i)
112 return i;
113
114 if (kind)
115 *kind = *(uint32_t *)buf;
116
117 if (fmt)
118 strcpy(fmt, (char *)(buf + sizeof(uint32_t)));
119 return (0);
120}
121
122
123
124
125
126static int sysctl_oldcvt(void *holdp, size_t holdlen, uint32_t kind)
127{
128 switch (kind & CTLTYPE) {
129 case CTLTYPE_INT:
130 case CTLTYPE_UINT:
131 *(uint32_t *)holdp = tswap32(*(uint32_t *)holdp);
132 break;
133#ifdef TARGET_ABI32
134 case CTLTYPE_LONG:
135 case CTLTYPE_ULONG:
136 *(uint32_t *)holdp = tswap32(*(long *)holdp);
137 break;
138#else
139 case CTLTYPE_LONG:
140 *(uint64_t *)holdp = tswap64(*(long *)holdp);
141 break;
142 case CTLTYPE_ULONG:
143 *(uint64_t *)holdp = tswap64(*(unsigned long *)holdp);
144 break;
145#endif
146#ifdef CTLTYPE_U64
147 case CTLTYPE_S64:
148 case CTLTYPE_U64:
149#else
150 case CTLTYPE_QUAD:
151#endif
152 *(uint64_t *)holdp = tswap64(*(uint64_t *)holdp);
153 break;
154 case CTLTYPE_STRING:
155 break;
156 default:
157
158 return -1;
159 }
160 return 0;
161}
162
163
164static abi_long do_freebsd_sysctl(abi_ulong namep, int32_t namelen, abi_ulong oldp,
165 abi_ulong oldlenp, abi_ulong newp, abi_ulong newlen)
166{
167 abi_long ret;
168 void *hnamep, *holdp, *hnewp = NULL;
169 size_t holdlen;
170 abi_ulong oldlen = 0;
171 int32_t *snamep = g_malloc(sizeof(int32_t) * namelen), *p, *q, i;
172 uint32_t kind = 0;
173
174 if (oldlenp)
175 get_user_ual(oldlen, oldlenp);
176 if (!(hnamep = lock_user(VERIFY_READ, namep, namelen, 1)))
177 return -TARGET_EFAULT;
178 if (newp && !(hnewp = lock_user(VERIFY_READ, newp, newlen, 1)))
179 return -TARGET_EFAULT;
180 if (!(holdp = lock_user(VERIFY_WRITE, oldp, oldlen, 0)))
181 return -TARGET_EFAULT;
182 holdlen = oldlen;
183 for (p = hnamep, q = snamep, i = 0; i < namelen; p++, i++)
184 *q++ = tswap32(*p);
185 oidfmt(snamep, namelen, NULL, &kind);
186
187 ret = get_errno(sysctl(snamep, namelen, holdp, &holdlen, hnewp, newlen));
188 if (!ret)
189 sysctl_oldcvt(holdp, holdlen, kind);
190 put_user_ual(holdlen, oldlenp);
191 unlock_user(hnamep, namep, 0);
192 unlock_user(holdp, oldp, holdlen);
193 if (hnewp)
194 unlock_user(hnewp, newp, 0);
195 g_free(snamep);
196 return ret;
197}
198#endif
199
200
201
202
203
204static abi_long lock_iovec(int type, struct iovec *vec, abi_ulong target_addr,
205 int count, int copy)
206{
207 struct target_iovec *target_vec;
208 abi_ulong base;
209 int i;
210
211 target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
212 if (!target_vec)
213 return -TARGET_EFAULT;
214 for (i = 0;i < count; i++) {
215 base = tswapl(target_vec[i].iov_base);
216 vec[i].iov_len = tswapl(target_vec[i].iov_len);
217 if (vec[i].iov_len != 0) {
218 vec[i].iov_base = lock_user(type, base, vec[i].iov_len, copy);
219
220
221 } else {
222
223 vec[i].iov_base = NULL;
224 }
225 }
226 unlock_user (target_vec, target_addr, 0);
227 return 0;
228}
229
230static abi_long unlock_iovec(struct iovec *vec, abi_ulong target_addr,
231 int count, int copy)
232{
233 struct target_iovec *target_vec;
234 abi_ulong base;
235 int i;
236
237 target_vec = lock_user(VERIFY_READ, target_addr, count * sizeof(struct target_iovec), 1);
238 if (!target_vec)
239 return -TARGET_EFAULT;
240 for (i = 0;i < count; i++) {
241 if (target_vec[i].iov_base) {
242 base = tswapl(target_vec[i].iov_base);
243 unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
244 }
245 }
246 unlock_user (target_vec, target_addr, 0);
247
248 return 0;
249}
250
251
252
253
254abi_long do_freebsd_syscall(void *cpu_env, int num, abi_long arg1,
255 abi_long arg2, abi_long arg3, abi_long arg4,
256 abi_long arg5, abi_long arg6, abi_long arg7,
257 abi_long arg8)
258{
259 CPUState *cpu = env_cpu(cpu_env);
260 abi_long ret;
261 void *p;
262
263#ifdef DEBUG
264 gemu_log("freebsd syscall %d\n", num);
265#endif
266 record_syscall_start(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, 0, 0);
267
268 if (do_strace)
269 print_freebsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
270
271 switch (num) {
272 case TARGET_FREEBSD_NR_exit:
273#ifdef CONFIG_GPROF
274 _mcleanup();
275#endif
276 gdb_exit(arg1);
277 qemu_plugin_user_exit();
278
279 _exit(arg1);
280 ret = 0;
281 break;
282 case TARGET_FREEBSD_NR_read:
283 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
284 goto efault;
285 ret = get_errno(read(arg1, p, arg3));
286 unlock_user(p, arg2, ret);
287 break;
288 case TARGET_FREEBSD_NR_write:
289 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
290 goto efault;
291 ret = get_errno(write(arg1, p, arg3));
292 unlock_user(p, arg2, 0);
293 break;
294 case TARGET_FREEBSD_NR_writev:
295 {
296 int count = arg3;
297 struct iovec *vec;
298
299 vec = alloca(count * sizeof(struct iovec));
300 if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)
301 goto efault;
302 ret = get_errno(writev(arg1, vec, count));
303 unlock_iovec(vec, arg2, count, 0);
304 }
305 break;
306 case TARGET_FREEBSD_NR_open:
307 if (!(p = lock_user_string(arg1)))
308 goto efault;
309 ret = get_errno(open(path(p),
310 target_to_host_bitmask(arg2, fcntl_flags_tbl),
311 arg3));
312 unlock_user(p, arg1, 0);
313 break;
314 case TARGET_FREEBSD_NR_mmap:
315 ret = get_errno(target_mmap(arg1, arg2, arg3,
316 target_to_host_bitmask(arg4, mmap_flags_tbl),
317 arg5,
318 arg6));
319 break;
320 case TARGET_FREEBSD_NR_mprotect:
321 ret = get_errno(target_mprotect(arg1, arg2, arg3));
322 break;
323 case TARGET_FREEBSD_NR_break:
324 ret = do_obreak(arg1);
325 break;
326#ifdef __FreeBSD__
327 case TARGET_FREEBSD_NR___sysctl:
328 ret = do_freebsd_sysctl(arg1, arg2, arg3, arg4, arg5, arg6);
329 break;
330#endif
331 case TARGET_FREEBSD_NR_sysarch:
332 ret = do_freebsd_sysarch(cpu_env, arg1, arg2);
333 break;
334 case TARGET_FREEBSD_NR_syscall:
335 case TARGET_FREEBSD_NR___syscall:
336 ret = do_freebsd_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,arg7,arg8,0);
337 break;
338 default:
339 ret = get_errno(syscall(num, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
340 break;
341 }
342 fail:
343#ifdef DEBUG
344 gemu_log(" = %ld\n", ret);
345#endif
346 if (do_strace)
347 print_freebsd_syscall_ret(num, ret);
348
349 record_syscall_return(cpu, num, ret);
350 return ret;
351 efault:
352 ret = -TARGET_EFAULT;
353 goto fail;
354}
355
356abi_long do_netbsd_syscall(void *cpu_env, int num, abi_long arg1,
357 abi_long arg2, abi_long arg3, abi_long arg4,
358 abi_long arg5, abi_long arg6)
359{
360 CPUState *cpu = env_cpu(cpu_env);
361 abi_long ret;
362 void *p;
363
364#ifdef DEBUG
365 gemu_log("netbsd syscall %d\n", num);
366#endif
367
368 record_syscall_start(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, 0, 0);
369
370 if (do_strace)
371 print_netbsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
372
373 switch (num) {
374 case TARGET_NETBSD_NR_exit:
375#ifdef CONFIG_GPROF
376 _mcleanup();
377#endif
378 gdb_exit(arg1);
379 qemu_plugin_user_exit();
380
381 _exit(arg1);
382 ret = 0;
383 break;
384 case TARGET_NETBSD_NR_read:
385 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
386 goto efault;
387 ret = get_errno(read(arg1, p, arg3));
388 unlock_user(p, arg2, ret);
389 break;
390 case TARGET_NETBSD_NR_write:
391 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
392 goto efault;
393 ret = get_errno(write(arg1, p, arg3));
394 unlock_user(p, arg2, 0);
395 break;
396 case TARGET_NETBSD_NR_open:
397 if (!(p = lock_user_string(arg1)))
398 goto efault;
399 ret = get_errno(open(path(p),
400 target_to_host_bitmask(arg2, fcntl_flags_tbl),
401 arg3));
402 unlock_user(p, arg1, 0);
403 break;
404 case TARGET_NETBSD_NR_mmap:
405 ret = get_errno(target_mmap(arg1, arg2, arg3,
406 target_to_host_bitmask(arg4, mmap_flags_tbl),
407 arg5,
408 arg6));
409 break;
410 case TARGET_NETBSD_NR_mprotect:
411 ret = get_errno(target_mprotect(arg1, arg2, arg3));
412 break;
413 case TARGET_NETBSD_NR_syscall:
414 case TARGET_NETBSD_NR___syscall:
415 ret = do_netbsd_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
416 break;
417 default:
418 ret = syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
419 break;
420 }
421 fail:
422#ifdef DEBUG
423 gemu_log(" = %ld\n", ret);
424#endif
425 if (do_strace)
426 print_netbsd_syscall_ret(num, ret);
427
428 record_syscall_return(cpu, num, ret);
429 return ret;
430 efault:
431 ret = -TARGET_EFAULT;
432 goto fail;
433}
434
435abi_long do_openbsd_syscall(void *cpu_env, int num, abi_long arg1,
436 abi_long arg2, abi_long arg3, abi_long arg4,
437 abi_long arg5, abi_long arg6)
438{
439 CPUState *cpu = env_cpu(cpu_env);
440 abi_long ret;
441 void *p;
442
443#ifdef DEBUG
444 gemu_log("openbsd syscall %d\n", num);
445#endif
446
447 record_syscall_start(cpu, num, arg1, arg2, arg3, arg4, arg5, arg6, 0, 0);
448
449 if (do_strace)
450 print_openbsd_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
451
452 switch (num) {
453 case TARGET_OPENBSD_NR_exit:
454#ifdef CONFIG_GPROF
455 _mcleanup();
456#endif
457 gdb_exit(arg1);
458 qemu_plugin_user_exit();
459
460 _exit(arg1);
461 ret = 0;
462 break;
463 case TARGET_OPENBSD_NR_read:
464 if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
465 goto efault;
466 ret = get_errno(read(arg1, p, arg3));
467 unlock_user(p, arg2, ret);
468 break;
469 case TARGET_OPENBSD_NR_write:
470 if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))
471 goto efault;
472 ret = get_errno(write(arg1, p, arg3));
473 unlock_user(p, arg2, 0);
474 break;
475 case TARGET_OPENBSD_NR_open:
476 if (!(p = lock_user_string(arg1)))
477 goto efault;
478 ret = get_errno(open(path(p),
479 target_to_host_bitmask(arg2, fcntl_flags_tbl),
480 arg3));
481 unlock_user(p, arg1, 0);
482 break;
483 case TARGET_OPENBSD_NR_mmap:
484 ret = get_errno(target_mmap(arg1, arg2, arg3,
485 target_to_host_bitmask(arg4, mmap_flags_tbl),
486 arg5,
487 arg6));
488 break;
489 case TARGET_OPENBSD_NR_mprotect:
490 ret = get_errno(target_mprotect(arg1, arg2, arg3));
491 break;
492 case TARGET_OPENBSD_NR_syscall:
493 case TARGET_OPENBSD_NR___syscall:
494 ret = do_openbsd_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
495 break;
496 default:
497 ret = syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);
498 break;
499 }
500 fail:
501#ifdef DEBUG
502 gemu_log(" = %ld\n", ret);
503#endif
504 if (do_strace)
505 print_openbsd_syscall_ret(num, ret);
506
507 record_syscall_return(cpu, num, ret);
508 return ret;
509 efault:
510 ret = -TARGET_EFAULT;
511 goto fail;
512}
513
514void syscall_init(void)
515{
516}
517
