]> git.proxmox.com Git - mirror_qemu.git/blob - linux-user/syscall.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
linux-user linkat() syscall, by Thayne Harbaugh.
[mirror_qemu.git] / linux-user / syscall.c
1 /*
2 * Linux syscalls
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <stdarg.h>
23 #include <string.h>
24 #include <elf.h>
25 #include <endian.h>
26 #include <errno.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29 #include <time.h>
30 #include <sys/types.h>
31 #include <sys/ipc.h>
32 #include <sys/msg.h>
33 #include <sys/wait.h>
34 #include <sys/time.h>
35 #include <sys/stat.h>
36 #include <sys/mount.h>
37 #include <sys/prctl.h>
38 #include <sys/resource.h>
39 #include <sys/mman.h>
40 #include <sys/swap.h>
41 #include <signal.h>
42 #include <sched.h>
43 #include <sys/socket.h>
44 #include <sys/uio.h>
45 #include <sys/poll.h>
46 #include <sys/times.h>
47 #include <sys/shm.h>
48 #include <sys/sem.h>
49 #include <sys/statfs.h>
50 #include <utime.h>
51 #include <sys/sysinfo.h>
52 //#include <sys/user.h>
53 #include <netinet/ip.h>
54 #include <netinet/tcp.h>
55
56 #define termios host_termios
57 #define winsize host_winsize
58 #define termio host_termio
59 #define sgttyb host_sgttyb /* same as target */
60 #define tchars host_tchars /* same as target */
61 #define ltchars host_ltchars /* same as target */
62
63 #include <linux/termios.h>
64 #include <linux/unistd.h>
65 #include <linux/utsname.h>
66 #include <linux/cdrom.h>
67 #include <linux/hdreg.h>
68 #include <linux/soundcard.h>
69 #include <linux/dirent.h>
70 #include <linux/kd.h>
71
72 #include "qemu.h"
73
74 //#define DEBUG
75
76 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_SPARC) \
77 || defined(TARGET_M68K) || defined(TARGET_SH4)
78 /* 16 bit uid wrappers emulation */
79 #define USE_UID16
80 #endif
81
82 //#include <linux/msdos_fs.h>
83 #define VFAT_IOCTL_READDIR_BOTH _IOR('r', 1, struct dirent [2])
84 #define VFAT_IOCTL_READDIR_SHORT _IOR('r', 2, struct dirent [2])
85
86
87 #undef _syscall0
88 #undef _syscall1
89 #undef _syscall2
90 #undef _syscall3
91 #undef _syscall4
92 #undef _syscall5
93 #undef _syscall6
94
95 #define _syscall0(type,name) \
96 type name (void) \
97 { \
98 return syscall(__NR_##name); \
99 }
100
101 #define _syscall1(type,name,type1,arg1) \
102 type name (type1 arg1) \
103 { \
104 return syscall(__NR_##name, arg1); \
105 }
106
107 #define _syscall2(type,name,type1,arg1,type2,arg2) \
108 type name (type1 arg1,type2 arg2) \
109 { \
110 return syscall(__NR_##name, arg1, arg2); \
111 }
112
113 #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
114 type name (type1 arg1,type2 arg2,type3 arg3) \
115 { \
116 return syscall(__NR_##name, arg1, arg2, arg3); \
117 }
118
119 #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
120 type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
121 { \
122 return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
123 }
124
125 #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
126 type5,arg5) \
127 type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
128 { \
129 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
130 }
131
132
133 #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
134 type5,arg5,type6,arg6) \
135 type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,type6 arg6) \
136 { \
137 return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
138 }
139
140
141 #define __NR_sys_uname __NR_uname
142 #define __NR_sys_fchownat __NR_fchownat
143 #define __NR_sys_getcwd1 __NR_getcwd
144 #define __NR_sys_getdents __NR_getdents
145 #define __NR_sys_getdents64 __NR_getdents64
146 #define __NR_sys_linkat __NR_linkat
147 #define __NR_sys_mkdirat __NR_mkdirat
148 #define __NR_sys_mknodat __NR_mknodat
149 #define __NR_sys_openat __NR_openat
150 #define __NR_sys_renameat __NR_renameat
151 #define __NR_sys_rt_sigqueueinfo __NR_rt_sigqueueinfo
152 #define __NR_sys_syslog __NR_syslog
153 #define __NR_sys_tgkill __NR_tgkill
154 #define __NR_sys_tkill __NR_tkill
155 #define __NR_sys_unlinkat __NR_unlinkat
156
157 #if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__)
158 #define __NR__llseek __NR_lseek
159 #endif
160
161 #ifdef __NR_gettid
162 _syscall0(int, gettid)
163 #else
164 static int gettid(void) {
165 return -ENOSYS;
166 }
167 #endif
168 _syscall1(int,sys_uname,struct new_utsname *,buf)
169 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)
170 _syscall5(int,sys_fchownat,int,dirfd,const char *,pathname,
171 uid_t,owner,gid_t,group,int,flags)
172 #endif
173 _syscall2(int,sys_getcwd1,char *,buf,size_t,size)
174 _syscall3(int, sys_getdents, uint, fd, struct dirent *, dirp, uint, count);
175 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
176 _syscall3(int, sys_getdents64, uint, fd, struct dirent64 *, dirp, uint, count);
177 #endif
178 _syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo,
179 loff_t *, res, uint, wh);
180 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
181 _syscall5(int,sys_linkat,int,olddirfd,const char *,oldpath,
182 int,newdirfd,const char *,newpath,int,flags)
183 #endif
184 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
185 _syscall3(int,sys_mkdirat,int,dirfd,const char *,pathname,mode_t,mode)
186 #endif
187 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
188 _syscall4(int,sys_mknodat,int,dirfd,const char *,pathname,
189 mode_t,mode,dev_t,dev)
190 #endif
191 #if defined(TARGET_NR_openat) && defined(__NR_openat)
192 _syscall4(int,sys_openat,int,dirfd,const char *,pathname,int,flags,mode_t,mode)
193 #endif
194 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
195 _syscall4(int,sys_renameat,int,olddirfd,const char *,oldpath,
196 int,newdirfd,const char *,newpath)
197 #endif
198 _syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo)
199 _syscall3(int,sys_syslog,int,type,char*,bufp,int,len)
200 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
201 _syscall3(int,sys_tgkill,int,tgid,int,pid,int,sig)
202 #endif
203 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
204 _syscall2(int,sys_tkill,int,tid,int,sig)
205 #endif
206 #ifdef __NR_exit_group
207 _syscall1(int,exit_group,int,error_code)
208 #endif
209 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
210 _syscall1(int,set_tid_address,int *,tidptr)
211 #endif
212 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
213 _syscall3(int,sys_unlinkat,int,dirfd,const char *,pathname,int,flags)
214 #endif
215
216 extern int personality(int);
217 extern int flock(int, int);
218 extern int setfsuid(int);
219 extern int setfsgid(int);
220 extern int setresuid(uid_t, uid_t, uid_t);
221 extern int getresuid(uid_t *, uid_t *, uid_t *);
222 extern int setresgid(gid_t, gid_t, gid_t);
223 extern int getresgid(gid_t *, gid_t *, gid_t *);
224 extern int setgroups(int, gid_t *);
225
226 /*
227 * This list is the union of errno values overridden in asm-<arch>/errno.h
228 * minus the errnos that are not actually generic to all archs.
229 */
230 static uint16_t host_to_target_errno_table[1200] = {
231 [EIDRM] = TARGET_EIDRM,
232 [ECHRNG] = TARGET_ECHRNG,
233 [EL2NSYNC] = TARGET_EL2NSYNC,
234 [EL3HLT] = TARGET_EL3HLT,
235 [EL3RST] = TARGET_EL3RST,
236 [ELNRNG] = TARGET_ELNRNG,
237 [EUNATCH] = TARGET_EUNATCH,
238 [ENOCSI] = TARGET_ENOCSI,
239 [EL2HLT] = TARGET_EL2HLT,
240 [EDEADLK] = TARGET_EDEADLK,
241 [ENOLCK] = TARGET_ENOLCK,
242 [EBADE] = TARGET_EBADE,
243 [EBADR] = TARGET_EBADR,
244 [EXFULL] = TARGET_EXFULL,
245 [ENOANO] = TARGET_ENOANO,
246 [EBADRQC] = TARGET_EBADRQC,
247 [EBADSLT] = TARGET_EBADSLT,
248 [EBFONT] = TARGET_EBFONT,
249 [ENOSTR] = TARGET_ENOSTR,
250 [ENODATA] = TARGET_ENODATA,
251 [ETIME] = TARGET_ETIME,
252 [ENOSR] = TARGET_ENOSR,
253 [ENONET] = TARGET_ENONET,
254 [ENOPKG] = TARGET_ENOPKG,
255 [EREMOTE] = TARGET_EREMOTE,
256 [ENOLINK] = TARGET_ENOLINK,
257 [EADV] = TARGET_EADV,
258 [ESRMNT] = TARGET_ESRMNT,
259 [ECOMM] = TARGET_ECOMM,
260 [EPROTO] = TARGET_EPROTO,
261 [EDOTDOT] = TARGET_EDOTDOT,
262 [EMULTIHOP] = TARGET_EMULTIHOP,
263 [EBADMSG] = TARGET_EBADMSG,
264 [ENAMETOOLONG] = TARGET_ENAMETOOLONG,
265 [EOVERFLOW] = TARGET_EOVERFLOW,
266 [ENOTUNIQ] = TARGET_ENOTUNIQ,
267 [EBADFD] = TARGET_EBADFD,
268 [EREMCHG] = TARGET_EREMCHG,
269 [ELIBACC] = TARGET_ELIBACC,
270 [ELIBBAD] = TARGET_ELIBBAD,
271 [ELIBSCN] = TARGET_ELIBSCN,
272 [ELIBMAX] = TARGET_ELIBMAX,
273 [ELIBEXEC] = TARGET_ELIBEXEC,
274 [EILSEQ] = TARGET_EILSEQ,
275 [ENOSYS] = TARGET_ENOSYS,
276 [ELOOP] = TARGET_ELOOP,
277 [ERESTART] = TARGET_ERESTART,
278 [ESTRPIPE] = TARGET_ESTRPIPE,
279 [ENOTEMPTY] = TARGET_ENOTEMPTY,
280 [EUSERS] = TARGET_EUSERS,
281 [ENOTSOCK] = TARGET_ENOTSOCK,
282 [EDESTADDRREQ] = TARGET_EDESTADDRREQ,
283 [EMSGSIZE] = TARGET_EMSGSIZE,
284 [EPROTOTYPE] = TARGET_EPROTOTYPE,
285 [ENOPROTOOPT] = TARGET_ENOPROTOOPT,
286 [EPROTONOSUPPORT] = TARGET_EPROTONOSUPPORT,
287 [ESOCKTNOSUPPORT] = TARGET_ESOCKTNOSUPPORT,
288 [EOPNOTSUPP] = TARGET_EOPNOTSUPP,
289 [EPFNOSUPPORT] = TARGET_EPFNOSUPPORT,
290 [EAFNOSUPPORT] = TARGET_EAFNOSUPPORT,
291 [EADDRINUSE] = TARGET_EADDRINUSE,
292 [EADDRNOTAVAIL] = TARGET_EADDRNOTAVAIL,
293 [ENETDOWN] = TARGET_ENETDOWN,
294 [ENETUNREACH] = TARGET_ENETUNREACH,
295 [ENETRESET] = TARGET_ENETRESET,
296 [ECONNABORTED] = TARGET_ECONNABORTED,
297 [ECONNRESET] = TARGET_ECONNRESET,
298 [ENOBUFS] = TARGET_ENOBUFS,
299 [EISCONN] = TARGET_EISCONN,
300 [ENOTCONN] = TARGET_ENOTCONN,
301 [EUCLEAN] = TARGET_EUCLEAN,
302 [ENOTNAM] = TARGET_ENOTNAM,
303 [ENAVAIL] = TARGET_ENAVAIL,
304 [EISNAM] = TARGET_EISNAM,
305 [EREMOTEIO] = TARGET_EREMOTEIO,
306 [ESHUTDOWN] = TARGET_ESHUTDOWN,
307 [ETOOMANYREFS] = TARGET_ETOOMANYREFS,
308 [ETIMEDOUT] = TARGET_ETIMEDOUT,
309 [ECONNREFUSED] = TARGET_ECONNREFUSED,
310 [EHOSTDOWN] = TARGET_EHOSTDOWN,
311 [EHOSTUNREACH] = TARGET_EHOSTUNREACH,
312 [EALREADY] = TARGET_EALREADY,
313 [EINPROGRESS] = TARGET_EINPROGRESS,
314 [ESTALE] = TARGET_ESTALE,
315 [ECANCELED] = TARGET_ECANCELED,
316 [ENOMEDIUM] = TARGET_ENOMEDIUM,
317 [EMEDIUMTYPE] = TARGET_EMEDIUMTYPE,
318 #ifdef ENOKEY
319 [ENOKEY] = TARGET_ENOKEY,
320 #endif
321 #ifdef EKEYEXPIRED
322 [EKEYEXPIRED] = TARGET_EKEYEXPIRED,
323 #endif
324 #ifdef EKEYREVOKED
325 [EKEYREVOKED] = TARGET_EKEYREVOKED,
326 #endif
327 #ifdef EKEYREJECTED
328 [EKEYREJECTED] = TARGET_EKEYREJECTED,
329 #endif
330 #ifdef EOWNERDEAD
331 [EOWNERDEAD] = TARGET_EOWNERDEAD,
332 #endif
333 #ifdef ENOTRECOVERABLE
334 [ENOTRECOVERABLE] = TARGET_ENOTRECOVERABLE,
335 #endif
336 };
337
338 static inline int host_to_target_errno(int err)
339 {
340 if(host_to_target_errno_table[err])
341 return host_to_target_errno_table[err];
342 return err;
343 }
344
345 static inline long get_errno(long ret)
346 {
347 if (ret == -1)
348 return -host_to_target_errno(errno);
349 else
350 return ret;
351 }
352
353 static inline int is_error(long ret)
354 {
355 return (unsigned long)ret >= (unsigned long)(-4096);
356 }
357
358 static target_ulong target_brk;
359 static target_ulong target_original_brk;
360
361 void target_set_brk(target_ulong new_brk)
362 {
363 target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
364 }
365
366 long do_brk(target_ulong new_brk)
367 {
368 target_ulong brk_page;
369 long mapped_addr;
370 int new_alloc_size;
371
372 if (!new_brk)
373 return target_brk;
374 if (new_brk < target_original_brk)
375 return -ENOMEM;
376
377 brk_page = HOST_PAGE_ALIGN(target_brk);
378
379 /* If the new brk is less than this, set it and we're done... */
380 if (new_brk < brk_page) {
381 target_brk = new_brk;
382 return target_brk;
383 }
384
385 /* We need to allocate more memory after the brk... */
386 new_alloc_size = HOST_PAGE_ALIGN(new_brk - brk_page + 1);
387 mapped_addr = get_errno(target_mmap(brk_page, new_alloc_size,
388 PROT_READ|PROT_WRITE,
389 MAP_ANON|MAP_FIXED|MAP_PRIVATE, 0, 0));
390 if (is_error(mapped_addr)) {
391 return mapped_addr;
392 } else {
393 target_brk = new_brk;
394 return target_brk;
395 }
396 }
397
398 static inline fd_set *target_to_host_fds(fd_set *fds,
399 target_long *target_fds, int n)
400 {
401 #if !defined(BSWAP_NEEDED) && !defined(WORDS_BIGENDIAN)
402 return (fd_set *)target_fds;
403 #else
404 int i, b;
405 if (target_fds) {
406 FD_ZERO(fds);
407 for(i = 0;i < n; i++) {
408 b = (tswapl(target_fds[i / TARGET_LONG_BITS]) >>
409 (i & (TARGET_LONG_BITS - 1))) & 1;
410 if (b)
411 FD_SET(i, fds);
412 }
413 return fds;
414 } else {
415 return NULL;
416 }
417 #endif
418 }
419
420 static inline void host_to_target_fds(target_long *target_fds,
421 fd_set *fds, int n)
422 {
423 #if !defined(BSWAP_NEEDED) && !defined(WORDS_BIGENDIAN)
424 /* nothing to do */
425 #else
426 int i, nw, j, k;
427 target_long v;
428
429 if (target_fds) {
430 nw = (n + TARGET_LONG_BITS - 1) / TARGET_LONG_BITS;
431 k = 0;
432 for(i = 0;i < nw; i++) {
433 v = 0;
434 for(j = 0; j < TARGET_LONG_BITS; j++) {
435 v |= ((FD_ISSET(k, fds) != 0) << j);
436 k++;
437 }
438 target_fds[i] = tswapl(v);
439 }
440 }
441 #endif
442 }
443
444 #if defined(__alpha__)
445 #define HOST_HZ 1024
446 #else
447 #define HOST_HZ 100
448 #endif
449
450 static inline long host_to_target_clock_t(long ticks)
451 {
452 #if HOST_HZ == TARGET_HZ
453 return ticks;
454 #else
455 return ((int64_t)ticks * TARGET_HZ) / HOST_HZ;
456 #endif
457 }
458
459 static inline void host_to_target_rusage(target_ulong target_addr,
460 const struct rusage *rusage)
461 {
462 struct target_rusage *target_rusage;
463
464 lock_user_struct(target_rusage, target_addr, 0);
465 target_rusage->ru_utime.tv_sec = tswapl(rusage->ru_utime.tv_sec);
466 target_rusage->ru_utime.tv_usec = tswapl(rusage->ru_utime.tv_usec);
467 target_rusage->ru_stime.tv_sec = tswapl(rusage->ru_stime.tv_sec);
468 target_rusage->ru_stime.tv_usec = tswapl(rusage->ru_stime.tv_usec);
469 target_rusage->ru_maxrss = tswapl(rusage->ru_maxrss);
470 target_rusage->ru_ixrss = tswapl(rusage->ru_ixrss);
471 target_rusage->ru_idrss = tswapl(rusage->ru_idrss);
472 target_rusage->ru_isrss = tswapl(rusage->ru_isrss);
473 target_rusage->ru_minflt = tswapl(rusage->ru_minflt);
474 target_rusage->ru_majflt = tswapl(rusage->ru_majflt);
475 target_rusage->ru_nswap = tswapl(rusage->ru_nswap);
476 target_rusage->ru_inblock = tswapl(rusage->ru_inblock);
477 target_rusage->ru_oublock = tswapl(rusage->ru_oublock);
478 target_rusage->ru_msgsnd = tswapl(rusage->ru_msgsnd);
479 target_rusage->ru_msgrcv = tswapl(rusage->ru_msgrcv);
480 target_rusage->ru_nsignals = tswapl(rusage->ru_nsignals);
481 target_rusage->ru_nvcsw = tswapl(rusage->ru_nvcsw);
482 target_rusage->ru_nivcsw = tswapl(rusage->ru_nivcsw);
483 unlock_user_struct(target_rusage, target_addr, 1);
484 }
485
486 static inline void target_to_host_timeval(struct timeval *tv,
487 target_ulong target_addr)
488 {
489 struct target_timeval *target_tv;
490
491 lock_user_struct(target_tv, target_addr, 1);
492 tv->tv_sec = tswapl(target_tv->tv_sec);
493 tv->tv_usec = tswapl(target_tv->tv_usec);
494 unlock_user_struct(target_tv, target_addr, 0);
495 }
496
497 static inline void host_to_target_timeval(target_ulong target_addr,
498 const struct timeval *tv)
499 {
500 struct target_timeval *target_tv;
501
502 lock_user_struct(target_tv, target_addr, 0);
503 target_tv->tv_sec = tswapl(tv->tv_sec);
504 target_tv->tv_usec = tswapl(tv->tv_usec);
505 unlock_user_struct(target_tv, target_addr, 1);
506 }
507
508
509 static long do_select(long n,
510 target_ulong rfd_p, target_ulong wfd_p,
511 target_ulong efd_p, target_ulong target_tv)
512 {
513 fd_set rfds, wfds, efds;
514 fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
515 target_long *target_rfds, *target_wfds, *target_efds;
516 struct timeval tv, *tv_ptr;
517 long ret;
518 int ok;
519
520 if (rfd_p) {
521 target_rfds = lock_user(rfd_p, sizeof(target_long) * n, 1);
522 rfds_ptr = target_to_host_fds(&rfds, target_rfds, n);
523 } else {
524 target_rfds = NULL;
525 rfds_ptr = NULL;
526 }
527 if (wfd_p) {
528 target_wfds = lock_user(wfd_p, sizeof(target_long) * n, 1);
529 wfds_ptr = target_to_host_fds(&wfds, target_wfds, n);
530 } else {
531 target_wfds = NULL;
532 wfds_ptr = NULL;
533 }
534 if (efd_p) {
535 target_efds = lock_user(efd_p, sizeof(target_long) * n, 1);
536 efds_ptr = target_to_host_fds(&efds, target_efds, n);
537 } else {
538 target_efds = NULL;
539 efds_ptr = NULL;
540 }
541
542 if (target_tv) {
543 target_to_host_timeval(&tv, target_tv);
544 tv_ptr = &tv;
545 } else {
546 tv_ptr = NULL;
547 }
548 ret = get_errno(select(n, rfds_ptr, wfds_ptr, efds_ptr, tv_ptr));
549 ok = !is_error(ret);
550
551 if (ok) {
552 host_to_target_fds(target_rfds, rfds_ptr, n);
553 host_to_target_fds(target_wfds, wfds_ptr, n);
554 host_to_target_fds(target_efds, efds_ptr, n);
555
556 if (target_tv) {
557 host_to_target_timeval(target_tv, &tv);
558 }
559 }
560 if (target_rfds)
561 unlock_user(target_rfds, rfd_p, ok ? sizeof(target_long) * n : 0);
562 if (target_wfds)
563 unlock_user(target_wfds, wfd_p, ok ? sizeof(target_long) * n : 0);
564 if (target_efds)
565 unlock_user(target_efds, efd_p, ok ? sizeof(target_long) * n : 0);
566
567 return ret;
568 }
569
570 static inline void target_to_host_sockaddr(struct sockaddr *addr,
571 target_ulong target_addr,
572 socklen_t len)
573 {
574 struct target_sockaddr *target_saddr;
575
576 target_saddr = lock_user(target_addr, len, 1);
577 memcpy(addr, target_saddr, len);
578 addr->sa_family = tswap16(target_saddr->sa_family);
579 unlock_user(target_saddr, target_addr, 0);
580 }
581
582 static inline void host_to_target_sockaddr(target_ulong target_addr,
583 struct sockaddr *addr,
584 socklen_t len)
585 {
586 struct target_sockaddr *target_saddr;
587
588 target_saddr = lock_user(target_addr, len, 0);
589 memcpy(target_saddr, addr, len);
590 target_saddr->sa_family = tswap16(addr->sa_family);
591 unlock_user(target_saddr, target_addr, len);
592 }
593
594 /* ??? Should this also swap msgh->name? */
595 static inline void target_to_host_cmsg(struct msghdr *msgh,
596 struct target_msghdr *target_msgh)
597 {
598 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
599 struct target_cmsghdr *target_cmsg = TARGET_CMSG_FIRSTHDR(target_msgh);
600 socklen_t space = 0;
601
602 while (cmsg && target_cmsg) {
603 void *data = CMSG_DATA(cmsg);
604 void *target_data = TARGET_CMSG_DATA(target_cmsg);
605
606 int len = tswapl(target_cmsg->cmsg_len)
607 - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr));
608
609 space += CMSG_SPACE(len);
610 if (space > msgh->msg_controllen) {
611 space -= CMSG_SPACE(len);
612 gemu_log("Host cmsg overflow\n");
613 break;
614 }
615
616 cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level);
617 cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type);
618 cmsg->cmsg_len = CMSG_LEN(len);
619
620 if (cmsg->cmsg_level != TARGET_SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
621 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
622 memcpy(data, target_data, len);
623 } else {
624 int *fd = (int *)data;
625 int *target_fd = (int *)target_data;
626 int i, numfds = len / sizeof(int);
627
628 for (i = 0; i < numfds; i++)
629 fd[i] = tswap32(target_fd[i]);
630 }
631
632 cmsg = CMSG_NXTHDR(msgh, cmsg);
633 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
634 }
635
636 msgh->msg_controllen = space;
637 }
638
639 /* ??? Should this also swap msgh->name? */
640 static inline void host_to_target_cmsg(struct target_msghdr *target_msgh,
641 struct msghdr *msgh)
642 {
643 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
644 struct target_cmsghdr *target_cmsg = TARGET_CMSG_FIRSTHDR(target_msgh);
645 socklen_t space = 0;
646
647 while (cmsg && target_cmsg) {
648 void *data = CMSG_DATA(cmsg);
649 void *target_data = TARGET_CMSG_DATA(target_cmsg);
650
651 int len = cmsg->cmsg_len - CMSG_ALIGN(sizeof (struct cmsghdr));
652
653 space += TARGET_CMSG_SPACE(len);
654 if (space > tswapl(target_msgh->msg_controllen)) {
655 space -= TARGET_CMSG_SPACE(len);
656 gemu_log("Target cmsg overflow\n");
657 break;
658 }
659
660 target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level);
661 target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type);
662 target_cmsg->cmsg_len = tswapl(TARGET_CMSG_LEN(len));
663
664 if (cmsg->cmsg_level != TARGET_SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
665 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
666 memcpy(target_data, data, len);
667 } else {
668 int *fd = (int *)data;
669 int *target_fd = (int *)target_data;
670 int i, numfds = len / sizeof(int);
671
672 for (i = 0; i < numfds; i++)
673 target_fd[i] = tswap32(fd[i]);
674 }
675
676 cmsg = CMSG_NXTHDR(msgh, cmsg);
677 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
678 }
679
680 msgh->msg_controllen = tswapl(space);
681 }
682
683 static long do_setsockopt(int sockfd, int level, int optname,
684 target_ulong optval, socklen_t optlen)
685 {
686 int val, ret;
687
688 switch(level) {
689 case SOL_TCP:
690 /* TCP options all take an 'int' value. */
691 if (optlen < sizeof(uint32_t))
692 return -EINVAL;
693
694 val = tget32(optval);
695 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
696 break;
697 case SOL_IP:
698 switch(optname) {
699 case IP_TOS:
700 case IP_TTL:
701 case IP_HDRINCL:
702 case IP_ROUTER_ALERT:
703 case IP_RECVOPTS:
704 case IP_RETOPTS:
705 case IP_PKTINFO:
706 case IP_MTU_DISCOVER:
707 case IP_RECVERR:
708 case IP_RECVTOS:
709 #ifdef IP_FREEBIND
710 case IP_FREEBIND:
711 #endif
712 case IP_MULTICAST_TTL:
713 case IP_MULTICAST_LOOP:
714 val = 0;
715 if (optlen >= sizeof(uint32_t)) {
716 val = tget32(optval);
717 } else if (optlen >= 1) {
718 val = tget8(optval);
719 }
720 ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
721 break;
722 default:
723 goto unimplemented;
724 }
725 break;
726 case TARGET_SOL_SOCKET:
727 switch (optname) {
728 /* Options with 'int' argument. */
729 case TARGET_SO_DEBUG:
730 optname = SO_DEBUG;
731 break;
732 case TARGET_SO_REUSEADDR:
733 optname = SO_REUSEADDR;
734 break;
735 case TARGET_SO_TYPE:
736 optname = SO_TYPE;
737 break;
738 case TARGET_SO_ERROR:
739 optname = SO_ERROR;
740 break;
741 case TARGET_SO_DONTROUTE:
742 optname = SO_DONTROUTE;
743 break;
744 case TARGET_SO_BROADCAST:
745 optname = SO_BROADCAST;
746 break;
747 case TARGET_SO_SNDBUF:
748 optname = SO_SNDBUF;
749 break;
750 case TARGET_SO_RCVBUF:
751 optname = SO_RCVBUF;
752 break;
753 case TARGET_SO_KEEPALIVE:
754 optname = SO_KEEPALIVE;
755 break;
756 case TARGET_SO_OOBINLINE:
757 optname = SO_OOBINLINE;
758 break;
759 case TARGET_SO_NO_CHECK:
760 optname = SO_NO_CHECK;
761 break;
762 case TARGET_SO_PRIORITY:
763 optname = SO_PRIORITY;
764 break;
765 #ifdef SO_BSDCOMPAT
766 case TARGET_SO_BSDCOMPAT:
767 optname = SO_BSDCOMPAT;
768 break;
769 #endif
770 case TARGET_SO_PASSCRED:
771 optname = SO_PASSCRED;
772 break;
773 case TARGET_SO_TIMESTAMP:
774 optname = SO_TIMESTAMP;
775 break;
776 case TARGET_SO_RCVLOWAT:
777 optname = SO_RCVLOWAT;
778 break;
779 case TARGET_SO_RCVTIMEO:
780 optname = SO_RCVTIMEO;
781 break;
782 case TARGET_SO_SNDTIMEO:
783 optname = SO_SNDTIMEO;
784 break;
785 break;
786 default:
787 goto unimplemented;
788 }
789 if (optlen < sizeof(uint32_t))
790 return -EINVAL;
791
792 val = tget32(optval);
793 ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val)));
794 break;
795 default:
796 unimplemented:
797 gemu_log("Unsupported setsockopt level=%d optname=%d \n", level, optname);
798 ret = -ENOSYS;
799 }
800 return ret;
801 }
802
803 static long do_getsockopt(int sockfd, int level, int optname,
804 target_ulong optval, target_ulong optlen)
805 {
806 int len, lv, val, ret;
807
808 switch(level) {
809 case TARGET_SOL_SOCKET:
810 level = SOL_SOCKET;
811 switch (optname) {
812 case TARGET_SO_LINGER:
813 case TARGET_SO_RCVTIMEO:
814 case TARGET_SO_SNDTIMEO:
815 case TARGET_SO_PEERCRED:
816 case TARGET_SO_PEERNAME:
817 /* These don't just return a single integer */
818 goto unimplemented;
819 default:
820 goto int_case;
821 }
822 break;
823 case SOL_TCP:
824 /* TCP options all take an 'int' value. */
825 int_case:
826 len = tget32(optlen);
827 if (len < 0)
828 return -EINVAL;
829 lv = sizeof(int);
830 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
831 if (ret < 0)
832 return ret;
833 val = tswap32(val);
834 if (len > lv)
835 len = lv;
836 if (len == 4)
837 tput32(optval, val);
838 else
839 tput8(optval, val);
840 tput32(optlen, len);
841 break;
842 case SOL_IP:
843 switch(optname) {
844 case IP_TOS:
845 case IP_TTL:
846 case IP_HDRINCL:
847 case IP_ROUTER_ALERT:
848 case IP_RECVOPTS:
849 case IP_RETOPTS:
850 case IP_PKTINFO:
851 case IP_MTU_DISCOVER:
852 case IP_RECVERR:
853 case IP_RECVTOS:
854 #ifdef IP_FREEBIND
855 case IP_FREEBIND:
856 #endif
857 case IP_MULTICAST_TTL:
858 case IP_MULTICAST_LOOP:
859 len = tget32(optlen);
860 if (len < 0)
861 return -EINVAL;
862 lv = sizeof(int);
863 ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
864 if (ret < 0)
865 return ret;
866 if (len < sizeof(int) && len > 0 && val >= 0 && val < 255) {
867 len = 1;
868 tput32(optlen, len);
869 tput8(optval, val);
870 } else {
871 if (len > sizeof(int))
872 len = sizeof(int);
873 tput32(optlen, len);
874 tput32(optval, val);
875 }
876 break;
877 default:
878 goto unimplemented;
879 }
880 break;
881 default:
882 unimplemented:
883 gemu_log("getsockopt level=%d optname=%d not yet supported\n",
884 level, optname);
885 ret = -ENOSYS;
886 break;
887 }
888 return ret;
889 }
890
891 static void lock_iovec(struct iovec *vec, target_ulong target_addr,
892 int count, int copy)
893 {
894 struct target_iovec *target_vec;
895 target_ulong base;
896 int i;
897
898 target_vec = lock_user(target_addr, count * sizeof(struct target_iovec), 1);
899 for(i = 0;i < count; i++) {
900 base = tswapl(target_vec[i].iov_base);
901 vec[i].iov_len = tswapl(target_vec[i].iov_len);
902 vec[i].iov_base = lock_user(base, vec[i].iov_len, copy);
903 }
904 unlock_user (target_vec, target_addr, 0);
905 }
906
907 static void unlock_iovec(struct iovec *vec, target_ulong target_addr,
908 int count, int copy)
909 {
910 struct target_iovec *target_vec;
911 target_ulong base;
912 int i;
913
914 target_vec = lock_user(target_addr, count * sizeof(struct target_iovec), 1);
915 for(i = 0;i < count; i++) {
916 base = tswapl(target_vec[i].iov_base);
917 unlock_user(vec[i].iov_base, base, copy ? vec[i].iov_len : 0);
918 }
919 unlock_user (target_vec, target_addr, 0);
920 }
921
922 static long do_socket(int domain, int type, int protocol)
923 {
924 #if defined(TARGET_MIPS)
925 switch(type) {
926 case TARGET_SOCK_DGRAM:
927 type = SOCK_DGRAM;
928 break;
929 case TARGET_SOCK_STREAM:
930 type = SOCK_STREAM;
931 break;
932 case TARGET_SOCK_RAW:
933 type = SOCK_RAW;
934 break;
935 case TARGET_SOCK_RDM:
936 type = SOCK_RDM;
937 break;
938 case TARGET_SOCK_SEQPACKET:
939 type = SOCK_SEQPACKET;
940 break;
941 case TARGET_SOCK_PACKET:
942 type = SOCK_PACKET;
943 break;
944 }
945 #endif
946 return get_errno(socket(domain, type, protocol));
947 }
948
949 static long do_bind(int sockfd, target_ulong target_addr,
950 socklen_t addrlen)
951 {
952 void *addr = alloca(addrlen);
953
954 target_to_host_sockaddr(addr, target_addr, addrlen);
955 return get_errno(bind(sockfd, addr, addrlen));
956 }
957
958 static long do_connect(int sockfd, target_ulong target_addr,
959 socklen_t addrlen)
960 {
961 void *addr = alloca(addrlen);
962
963 target_to_host_sockaddr(addr, target_addr, addrlen);
964 return get_errno(connect(sockfd, addr, addrlen));
965 }
966
967 static long do_sendrecvmsg(int fd, target_ulong target_msg,
968 int flags, int send)
969 {
970 long ret;
971 struct target_msghdr *msgp;
972 struct msghdr msg;
973 int count;
974 struct iovec *vec;
975 target_ulong target_vec;
976
977 lock_user_struct(msgp, target_msg, 1);
978 if (msgp->msg_name) {
979 msg.msg_namelen = tswap32(msgp->msg_namelen);
980 msg.msg_name = alloca(msg.msg_namelen);
981 target_to_host_sockaddr(msg.msg_name, tswapl(msgp->msg_name),
982 msg.msg_namelen);
983 } else {
984 msg.msg_name = NULL;
985 msg.msg_namelen = 0;
986 }
987 msg.msg_controllen = 2 * tswapl(msgp->msg_controllen);
988 msg.msg_control = alloca(msg.msg_controllen);
989 msg.msg_flags = tswap32(msgp->msg_flags);
990
991 count = tswapl(msgp->msg_iovlen);
992 vec = alloca(count * sizeof(struct iovec));
993 target_vec = tswapl(msgp->msg_iov);
994 lock_iovec(vec, target_vec, count, send);
995 msg.msg_iovlen = count;
996 msg.msg_iov = vec;
997
998 if (send) {
999 target_to_host_cmsg(&msg, msgp);
1000 ret = get_errno(sendmsg(fd, &msg, flags));
1001 } else {
1002 ret = get_errno(recvmsg(fd, &msg, flags));
1003 if (!is_error(ret))
1004 host_to_target_cmsg(msgp, &msg);
1005 }
1006 unlock_iovec(vec, target_vec, count, !send);
1007 return ret;
1008 }
1009
1010 static long do_accept(int fd, target_ulong target_addr,
1011 target_ulong target_addrlen)
1012 {
1013 socklen_t addrlen = tget32(target_addrlen);
1014 void *addr = alloca(addrlen);
1015 long ret;
1016
1017 ret = get_errno(accept(fd, addr, &addrlen));
1018 if (!is_error(ret)) {
1019 host_to_target_sockaddr(target_addr, addr, addrlen);
1020 tput32(target_addrlen, addrlen);
1021 }
1022 return ret;
1023 }
1024
1025 static long do_getpeername(int fd, target_ulong target_addr,
1026 target_ulong target_addrlen)
1027 {
1028 socklen_t addrlen = tget32(target_addrlen);
1029 void *addr = alloca(addrlen);
1030 long ret;
1031
1032 ret = get_errno(getpeername(fd, addr, &addrlen));
1033 if (!is_error(ret)) {
1034 host_to_target_sockaddr(target_addr, addr, addrlen);
1035 tput32(target_addrlen, addrlen);
1036 }
1037 return ret;
1038 }
1039
1040 static long do_getsockname(int fd, target_ulong target_addr,
1041 target_ulong target_addrlen)
1042 {
1043 socklen_t addrlen = tget32(target_addrlen);
1044 void *addr = alloca(addrlen);
1045 long ret;
1046
1047 ret = get_errno(getsockname(fd, addr, &addrlen));
1048 if (!is_error(ret)) {
1049 host_to_target_sockaddr(target_addr, addr, addrlen);
1050 tput32(target_addrlen, addrlen);
1051 }
1052 return ret;
1053 }
1054
1055 static long do_socketpair(int domain, int type, int protocol,
1056 target_ulong target_tab)
1057 {
1058 int tab[2];
1059 long ret;
1060
1061 ret = get_errno(socketpair(domain, type, protocol, tab));
1062 if (!is_error(ret)) {
1063 tput32(target_tab, tab[0]);
1064 tput32(target_tab + 4, tab[1]);
1065 }
1066 return ret;
1067 }
1068
1069 static long do_sendto(int fd, target_ulong msg, size_t len, int flags,
1070 target_ulong target_addr, socklen_t addrlen)
1071 {
1072 void *addr;
1073 void *host_msg;
1074 long ret;
1075
1076 host_msg = lock_user(msg, len, 1);
1077 if (target_addr) {
1078 addr = alloca(addrlen);
1079 target_to_host_sockaddr(addr, target_addr, addrlen);
1080 ret = get_errno(sendto(fd, host_msg, len, flags, addr, addrlen));
1081 } else {
1082 ret = get_errno(send(fd, host_msg, len, flags));
1083 }
1084 unlock_user(host_msg, msg, 0);
1085 return ret;
1086 }
1087
1088 static long do_recvfrom(int fd, target_ulong msg, size_t len, int flags,
1089 target_ulong target_addr, target_ulong target_addrlen)
1090 {
1091 socklen_t addrlen;
1092 void *addr;
1093 void *host_msg;
1094 long ret;
1095
1096 host_msg = lock_user(msg, len, 0);
1097 if (target_addr) {
1098 addrlen = tget32(target_addrlen);
1099 addr = alloca(addrlen);
1100 ret = get_errno(recvfrom(fd, host_msg, len, flags, addr, &addrlen));
1101 } else {
1102 addr = NULL; /* To keep compiler quiet. */
1103 ret = get_errno(recv(fd, host_msg, len, flags));
1104 }
1105 if (!is_error(ret)) {
1106 if (target_addr) {
1107 host_to_target_sockaddr(target_addr, addr, addrlen);
1108 tput32(target_addrlen, addrlen);
1109 }
1110 unlock_user(host_msg, msg, len);
1111 } else {
1112 unlock_user(host_msg, msg, 0);
1113 }
1114 return ret;
1115 }
1116
1117 static long do_socketcall(int num, target_ulong vptr)
1118 {
1119 long ret;
1120 const int n = sizeof(target_ulong);
1121
1122 switch(num) {
1123 case SOCKOP_socket:
1124 {
1125 int domain = tgetl(vptr);
1126 int type = tgetl(vptr + n);
1127 int protocol = tgetl(vptr + 2 * n);
1128 ret = do_socket(domain, type, protocol);
1129 }
1130 break;
1131 case SOCKOP_bind:
1132 {
1133 int sockfd = tgetl(vptr);
1134 target_ulong target_addr = tgetl(vptr + n);
1135 socklen_t addrlen = tgetl(vptr + 2 * n);
1136 ret = do_bind(sockfd, target_addr, addrlen);
1137 }
1138 break;
1139 case SOCKOP_connect:
1140 {
1141 int sockfd = tgetl(vptr);
1142 target_ulong target_addr = tgetl(vptr + n);
1143 socklen_t addrlen = tgetl(vptr + 2 * n);
1144 ret = do_connect(sockfd, target_addr, addrlen);
1145 }
1146 break;
1147 case SOCKOP_listen:
1148 {
1149 int sockfd = tgetl(vptr);
1150 int backlog = tgetl(vptr + n);
1151 ret = get_errno(listen(sockfd, backlog));
1152 }
1153 break;
1154 case SOCKOP_accept:
1155 {
1156 int sockfd = tgetl(vptr);
1157 target_ulong target_addr = tgetl(vptr + n);
1158 target_ulong target_addrlen = tgetl(vptr + 2 * n);
1159 ret = do_accept(sockfd, target_addr, target_addrlen);
1160 }
1161 break;
1162 case SOCKOP_getsockname:
1163 {
1164 int sockfd = tgetl(vptr);
1165 target_ulong target_addr = tgetl(vptr + n);
1166 target_ulong target_addrlen = tgetl(vptr + 2 * n);
1167 ret = do_getsockname(sockfd, target_addr, target_addrlen);
1168 }
1169 break;
1170 case SOCKOP_getpeername:
1171 {
1172 int sockfd = tgetl(vptr);
1173 target_ulong target_addr = tgetl(vptr + n);
1174 target_ulong target_addrlen = tgetl(vptr + 2 * n);
1175 ret = do_getpeername(sockfd, target_addr, target_addrlen);
1176 }
1177 break;
1178 case SOCKOP_socketpair:
1179 {
1180 int domain = tgetl(vptr);
1181 int type = tgetl(vptr + n);
1182 int protocol = tgetl(vptr + 2 * n);
1183 target_ulong tab = tgetl(vptr + 3 * n);
1184 ret = do_socketpair(domain, type, protocol, tab);
1185 }
1186 break;
1187 case SOCKOP_send:
1188 {
1189 int sockfd = tgetl(vptr);
1190 target_ulong msg = tgetl(vptr + n);
1191 size_t len = tgetl(vptr + 2 * n);
1192 int flags = tgetl(vptr + 3 * n);
1193 ret = do_sendto(sockfd, msg, len, flags, 0, 0);
1194 }
1195 break;
1196 case SOCKOP_recv:
1197 {
1198 int sockfd = tgetl(vptr);
1199 target_ulong msg = tgetl(vptr + n);
1200 size_t len = tgetl(vptr + 2 * n);
1201 int flags = tgetl(vptr + 3 * n);
1202 ret = do_recvfrom(sockfd, msg, len, flags, 0, 0);
1203 }
1204 break;
1205 case SOCKOP_sendto:
1206 {
1207 int sockfd = tgetl(vptr);
1208 target_ulong msg = tgetl(vptr + n);
1209 size_t len = tgetl(vptr + 2 * n);
1210 int flags = tgetl(vptr + 3 * n);
1211 target_ulong addr = tgetl(vptr + 4 * n);
1212 socklen_t addrlen = tgetl(vptr + 5 * n);
1213 ret = do_sendto(sockfd, msg, len, flags, addr, addrlen);
1214 }
1215 break;
1216 case SOCKOP_recvfrom:
1217 {
1218 int sockfd = tgetl(vptr);
1219 target_ulong msg = tgetl(vptr + n);
1220 size_t len = tgetl(vptr + 2 * n);
1221 int flags = tgetl(vptr + 3 * n);
1222 target_ulong addr = tgetl(vptr + 4 * n);
1223 target_ulong addrlen = tgetl(vptr + 5 * n);
1224 ret = do_recvfrom(sockfd, msg, len, flags, addr, addrlen);
1225 }
1226 break;
1227 case SOCKOP_shutdown:
1228 {
1229 int sockfd = tgetl(vptr);
1230 int how = tgetl(vptr + n);
1231
1232 ret = get_errno(shutdown(sockfd, how));
1233 }
1234 break;
1235 case SOCKOP_sendmsg:
1236 case SOCKOP_recvmsg:
1237 {
1238 int fd;
1239 target_ulong target_msg;
1240 int flags;
1241
1242 fd = tgetl(vptr);
1243 target_msg = tgetl(vptr + n);
1244 flags = tgetl(vptr + 2 * n);
1245
1246 ret = do_sendrecvmsg(fd, target_msg, flags,
1247 (num == SOCKOP_sendmsg));
1248 }
1249 break;
1250 case SOCKOP_setsockopt:
1251 {
1252 int sockfd = tgetl(vptr);
1253 int level = tgetl(vptr + n);
1254 int optname = tgetl(vptr + 2 * n);
1255 target_ulong optval = tgetl(vptr + 3 * n);
1256 socklen_t optlen = tgetl(vptr + 4 * n);
1257
1258 ret = do_setsockopt(sockfd, level, optname, optval, optlen);
1259 }
1260 break;
1261 case SOCKOP_getsockopt:
1262 {
1263 int sockfd = tgetl(vptr);
1264 int level = tgetl(vptr + n);
1265 int optname = tgetl(vptr + 2 * n);
1266 target_ulong optval = tgetl(vptr + 3 * n);
1267 target_ulong poptlen = tgetl(vptr + 4 * n);
1268
1269 ret = do_getsockopt(sockfd, level, optname, optval, poptlen);
1270 }
1271 break;
1272 default:
1273 gemu_log("Unsupported socketcall: %d\n", num);
1274 ret = -ENOSYS;
1275 break;
1276 }
1277 return ret;
1278 }
1279
1280 #define N_SHM_REGIONS 32
1281
1282 static struct shm_region {
1283 uint32_t start;
1284 uint32_t size;
1285 } shm_regions[N_SHM_REGIONS];
1286
1287 struct target_ipc_perm
1288 {
1289 target_long __key;
1290 target_ulong uid;
1291 target_ulong gid;
1292 target_ulong cuid;
1293 target_ulong cgid;
1294 unsigned short int mode;
1295 unsigned short int __pad1;
1296 unsigned short int __seq;
1297 unsigned short int __pad2;
1298 target_ulong __unused1;
1299 target_ulong __unused2;
1300 };
1301
1302 struct target_semid_ds
1303 {
1304 struct target_ipc_perm sem_perm;
1305 target_ulong sem_otime;
1306 target_ulong __unused1;
1307 target_ulong sem_ctime;
1308 target_ulong __unused2;
1309 target_ulong sem_nsems;
1310 target_ulong __unused3;
1311 target_ulong __unused4;
1312 };
1313
1314 static inline void target_to_host_ipc_perm(struct ipc_perm *host_ip,
1315 target_ulong target_addr)
1316 {
1317 struct target_ipc_perm *target_ip;
1318 struct target_semid_ds *target_sd;
1319
1320 lock_user_struct(target_sd, target_addr, 1);
1321 target_ip=&(target_sd->sem_perm);
1322 host_ip->__key = tswapl(target_ip->__key);
1323 host_ip->uid = tswapl(target_ip->uid);
1324 host_ip->gid = tswapl(target_ip->gid);
1325 host_ip->cuid = tswapl(target_ip->cuid);
1326 host_ip->cgid = tswapl(target_ip->cgid);
1327 host_ip->mode = tswapl(target_ip->mode);
1328 unlock_user_struct(target_sd, target_addr, 0);
1329 }
1330
1331 static inline void host_to_target_ipc_perm(target_ulong target_addr,
1332 struct ipc_perm *host_ip)
1333 {
1334 struct target_ipc_perm *target_ip;
1335 struct target_semid_ds *target_sd;
1336
1337 lock_user_struct(target_sd, target_addr, 0);
1338 target_ip = &(target_sd->sem_perm);
1339 target_ip->__key = tswapl(host_ip->__key);
1340 target_ip->uid = tswapl(host_ip->uid);
1341 target_ip->gid = tswapl(host_ip->gid);
1342 target_ip->cuid = tswapl(host_ip->cuid);
1343 target_ip->cgid = tswapl(host_ip->cgid);
1344 target_ip->mode = tswapl(host_ip->mode);
1345 unlock_user_struct(target_sd, target_addr, 1);
1346 }
1347
1348 static inline void target_to_host_semid_ds(struct semid_ds *host_sd,
1349 target_ulong target_addr)
1350 {
1351 struct target_semid_ds *target_sd;
1352
1353 lock_user_struct(target_sd, target_addr, 1);
1354 target_to_host_ipc_perm(&(host_sd->sem_perm),target_addr);
1355 host_sd->sem_nsems = tswapl(target_sd->sem_nsems);
1356 host_sd->sem_otime = tswapl(target_sd->sem_otime);
1357 host_sd->sem_ctime = tswapl(target_sd->sem_ctime);
1358 unlock_user_struct(target_sd, target_addr, 0);
1359 }
1360
1361 static inline void host_to_target_semid_ds(target_ulong target_addr,
1362 struct semid_ds *host_sd)
1363 {
1364 struct target_semid_ds *target_sd;
1365
1366 lock_user_struct(target_sd, target_addr, 0);
1367 host_to_target_ipc_perm(target_addr,&(host_sd->sem_perm));
1368 target_sd->sem_nsems = tswapl(host_sd->sem_nsems);
1369 target_sd->sem_otime = tswapl(host_sd->sem_otime);
1370 target_sd->sem_ctime = tswapl(host_sd->sem_ctime);
1371 unlock_user_struct(target_sd, target_addr, 1);
1372 }
1373
1374 union semun {
1375 int val;
1376 struct semid_ds *buf;
1377 unsigned short *array;
1378 };
1379
1380 union target_semun {
1381 int val;
1382 target_long buf;
1383 unsigned short int *array;
1384 };
1385
1386 static inline void target_to_host_semun(unsigned long cmd,
1387 union semun *host_su,
1388 target_ulong target_addr,
1389 struct semid_ds *ds)
1390 {
1391 union target_semun *target_su;
1392
1393 switch( cmd ) {
1394 case IPC_STAT:
1395 case IPC_SET:
1396 lock_user_struct(target_su, target_addr, 1);
1397 target_to_host_semid_ds(ds,target_su->buf);
1398 host_su->buf = ds;
1399 unlock_user_struct(target_su, target_addr, 0);
1400 break;
1401 case GETVAL:
1402 case SETVAL:
1403 lock_user_struct(target_su, target_addr, 1);
1404 host_su->val = tswapl(target_su->val);
1405 unlock_user_struct(target_su, target_addr, 0);
1406 break;
1407 case GETALL:
1408 case SETALL:
1409 lock_user_struct(target_su, target_addr, 1);
1410 *host_su->array = tswap16(*target_su->array);
1411 unlock_user_struct(target_su, target_addr, 0);
1412 break;
1413 default:
1414 gemu_log("semun operation not fully supported: %d\n", (int)cmd);
1415 }
1416 }
1417
1418 static inline void host_to_target_semun(unsigned long cmd,
1419 target_ulong target_addr,
1420 union semun *host_su,
1421 struct semid_ds *ds)
1422 {
1423 union target_semun *target_su;
1424
1425 switch( cmd ) {
1426 case IPC_STAT:
1427 case IPC_SET:
1428 lock_user_struct(target_su, target_addr, 0);
1429 host_to_target_semid_ds(target_su->buf,ds);
1430 unlock_user_struct(target_su, target_addr, 1);
1431 break;
1432 case GETVAL:
1433 case SETVAL:
1434 lock_user_struct(target_su, target_addr, 0);
1435 target_su->val = tswapl(host_su->val);
1436 unlock_user_struct(target_su, target_addr, 1);
1437 break;
1438 case GETALL:
1439 case SETALL:
1440 lock_user_struct(target_su, target_addr, 0);
1441 *target_su->array = tswap16(*host_su->array);
1442 unlock_user_struct(target_su, target_addr, 1);
1443 break;
1444 default:
1445 gemu_log("semun operation not fully supported: %d\n", (int)cmd);
1446 }
1447 }
1448
1449 static inline long do_semctl(long first, long second, long third, long ptr)
1450 {
1451 union semun arg;
1452 struct semid_ds dsarg;
1453 int cmd = third&0xff;
1454 long ret = 0;
1455
1456 switch( cmd ) {
1457 case GETVAL:
1458 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1459 ret = get_errno(semctl(first, second, cmd, arg));
1460 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1461 break;
1462 case SETVAL:
1463 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1464 ret = get_errno(semctl(first, second, cmd, arg));
1465 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1466 break;
1467 case GETALL:
1468 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1469 ret = get_errno(semctl(first, second, cmd, arg));
1470 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1471 break;
1472 case SETALL:
1473 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1474 ret = get_errno(semctl(first, second, cmd, arg));
1475 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1476 break;
1477 case IPC_STAT:
1478 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1479 ret = get_errno(semctl(first, second, cmd, arg));
1480 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1481 break;
1482 case IPC_SET:
1483 target_to_host_semun(cmd,&arg,ptr,&dsarg);
1484 ret = get_errno(semctl(first, second, cmd, arg));
1485 host_to_target_semun(cmd,ptr,&arg,&dsarg);
1486 break;
1487 default:
1488 ret = get_errno(semctl(first, second, cmd, arg));
1489 }
1490
1491 return ret;
1492 }
1493
1494 struct target_msqid_ds
1495 {
1496 struct target_ipc_perm msg_perm;
1497 target_ulong msg_stime;
1498 target_ulong __unused1;
1499 target_ulong msg_rtime;
1500 target_ulong __unused2;
1501 target_ulong msg_ctime;
1502 target_ulong __unused3;
1503 target_ulong __msg_cbytes;
1504 target_ulong msg_qnum;
1505 target_ulong msg_qbytes;
1506 target_ulong msg_lspid;
1507 target_ulong msg_lrpid;
1508 target_ulong __unused4;
1509 target_ulong __unused5;
1510 };
1511
1512 static inline void target_to_host_msqid_ds(struct msqid_ds *host_md,
1513 target_ulong target_addr)
1514 {
1515 struct target_msqid_ds *target_md;
1516
1517 lock_user_struct(target_md, target_addr, 1);
1518 target_to_host_ipc_perm(&(host_md->msg_perm),target_addr);
1519 host_md->msg_stime = tswapl(target_md->msg_stime);
1520 host_md->msg_rtime = tswapl(target_md->msg_rtime);
1521 host_md->msg_ctime = tswapl(target_md->msg_ctime);
1522 host_md->__msg_cbytes = tswapl(target_md->__msg_cbytes);
1523 host_md->msg_qnum = tswapl(target_md->msg_qnum);
1524 host_md->msg_qbytes = tswapl(target_md->msg_qbytes);
1525 host_md->msg_lspid = tswapl(target_md->msg_lspid);
1526 host_md->msg_lrpid = tswapl(target_md->msg_lrpid);
1527 unlock_user_struct(target_md, target_addr, 0);
1528 }
1529
1530 static inline void host_to_target_msqid_ds(target_ulong target_addr,
1531 struct msqid_ds *host_md)
1532 {
1533 struct target_msqid_ds *target_md;
1534
1535 lock_user_struct(target_md, target_addr, 0);
1536 host_to_target_ipc_perm(target_addr,&(host_md->msg_perm));
1537 target_md->msg_stime = tswapl(host_md->msg_stime);
1538 target_md->msg_rtime = tswapl(host_md->msg_rtime);
1539 target_md->msg_ctime = tswapl(host_md->msg_ctime);
1540 target_md->__msg_cbytes = tswapl(host_md->__msg_cbytes);
1541 target_md->msg_qnum = tswapl(host_md->msg_qnum);
1542 target_md->msg_qbytes = tswapl(host_md->msg_qbytes);
1543 target_md->msg_lspid = tswapl(host_md->msg_lspid);
1544 target_md->msg_lrpid = tswapl(host_md->msg_lrpid);
1545 unlock_user_struct(target_md, target_addr, 1);
1546 }
1547
1548 static inline long do_msgctl(long first, long second, long ptr)
1549 {
1550 struct msqid_ds dsarg;
1551 int cmd = second&0xff;
1552 long ret = 0;
1553 switch( cmd ) {
1554 case IPC_STAT:
1555 case IPC_SET:
1556 target_to_host_msqid_ds(&dsarg,ptr);
1557 ret = get_errno(msgctl(first, cmd, &dsarg));
1558 host_to_target_msqid_ds(ptr,&dsarg);
1559 default:
1560 ret = get_errno(msgctl(first, cmd, &dsarg));
1561 }
1562 return ret;
1563 }
1564
1565 struct target_msgbuf {
1566 target_ulong mtype;
1567 char mtext[1];
1568 };
1569
1570 static inline long do_msgsnd(long msqid, long msgp, long msgsz, long msgflg)
1571 {
1572 struct target_msgbuf *target_mb;
1573 struct msgbuf *host_mb;
1574 long ret = 0;
1575
1576 lock_user_struct(target_mb,msgp,0);
1577 host_mb = malloc(msgsz+sizeof(long));
1578 host_mb->mtype = tswapl(target_mb->mtype);
1579 memcpy(host_mb->mtext,target_mb->mtext,msgsz);
1580 ret = get_errno(msgsnd(msqid, host_mb, msgsz, msgflg));
1581 free(host_mb);
1582 unlock_user_struct(target_mb, msgp, 0);
1583
1584 return ret;
1585 }
1586
1587 static inline long do_msgrcv(long msqid, long msgp, long msgsz, long msgtype, long msgflg)
1588 {
1589 struct target_msgbuf *target_mb;
1590 struct msgbuf *host_mb;
1591 long ret = 0;
1592
1593 lock_user_struct(target_mb, msgp, 0);
1594 host_mb = malloc(msgsz+sizeof(long));
1595 ret = get_errno(msgrcv(msqid, host_mb, msgsz, 1, msgflg));
1596 if (ret > 0)
1597 memcpy(target_mb->mtext, host_mb->mtext, ret);
1598 target_mb->mtype = tswapl(host_mb->mtype);
1599 free(host_mb);
1600 unlock_user_struct(target_mb, msgp, 0);
1601
1602 return ret;
1603 }
1604
1605 /* ??? This only works with linear mappings. */
1606 static long do_ipc(long call, long first, long second, long third,
1607 long ptr, long fifth)
1608 {
1609 int version;
1610 long ret = 0;
1611 unsigned long raddr;
1612 struct shmid_ds shm_info;
1613 int i;
1614
1615 version = call >> 16;
1616 call &= 0xffff;
1617
1618 switch (call) {
1619 case IPCOP_semop:
1620 ret = get_errno(semop(first,(struct sembuf *) ptr, second));
1621 break;
1622
1623 case IPCOP_semget:
1624 ret = get_errno(semget(first, second, third));
1625 break;
1626
1627 case IPCOP_semctl:
1628 ret = do_semctl(first, second, third, ptr);
1629 break;
1630
1631 case IPCOP_semtimedop:
1632 gemu_log("Unsupported ipc call: %ld (version %d)\n", call, version);
1633 ret = -ENOSYS;
1634 break;
1635
1636 case IPCOP_msgget:
1637 ret = get_errno(msgget(first, second));
1638 break;
1639
1640 case IPCOP_msgsnd:
1641 ret = do_msgsnd(first, ptr, second, third);
1642 break;
1643
1644 case IPCOP_msgctl:
1645 ret = do_msgctl(first, second, ptr);
1646 break;
1647
1648 case IPCOP_msgrcv:
1649 {
1650 struct ipc_kludge
1651 {
1652 void *__unbounded msgp;
1653 long int msgtyp;
1654 };
1655
1656 struct ipc_kludge *foo = (struct ipc_kludge *) ptr;
1657 struct msgbuf *msgp = (struct msgbuf *) foo->msgp;
1658
1659 ret = do_msgrcv(first, (long)msgp, second, 0, third);
1660
1661 }
1662 break;
1663
1664 case IPCOP_shmat:
1665 /* SHM_* flags are the same on all linux platforms */
1666 ret = get_errno((long) shmat(first, (void *) ptr, second));
1667 if (is_error(ret))
1668 break;
1669 raddr = ret;
1670 /* find out the length of the shared memory segment */
1671
1672 ret = get_errno(shmctl(first, IPC_STAT, &shm_info));
1673 if (is_error(ret)) {
1674 /* can't get length, bail out */
1675 shmdt((void *) raddr);
1676 break;
1677 }
1678 page_set_flags(raddr, raddr + shm_info.shm_segsz,
1679 PAGE_VALID | PAGE_READ |
1680 ((second & SHM_RDONLY)? 0: PAGE_WRITE));
1681 for (i = 0; i < N_SHM_REGIONS; ++i) {
1682 if (shm_regions[i].start == 0) {
1683 shm_regions[i].start = raddr;
1684 shm_regions[i].size = shm_info.shm_segsz;
1685 break;
1686 }
1687 }
1688 if (put_user(raddr, (uint32_t *)third))
1689 return -EFAULT;
1690 ret = 0;
1691 break;
1692 case IPCOP_shmdt:
1693 for (i = 0; i < N_SHM_REGIONS; ++i) {
1694 if (shm_regions[i].start == ptr) {
1695 shm_regions[i].start = 0;
1696 page_set_flags(ptr, shm_regions[i].size, 0);
1697 break;
1698 }
1699 }
1700 ret = get_errno(shmdt((void *) ptr));
1701 break;
1702
1703 case IPCOP_shmget:
1704 /* IPC_* flag values are the same on all linux platforms */
1705 ret = get_errno(shmget(first, second, third));
1706 break;
1707
1708 /* IPC_* and SHM_* command values are the same on all linux platforms */
1709 case IPCOP_shmctl:
1710 switch(second) {
1711 case IPC_RMID:
1712 case SHM_LOCK:
1713 case SHM_UNLOCK:
1714 ret = get_errno(shmctl(first, second, NULL));
1715 break;
1716 default:
1717 goto unimplemented;
1718 }
1719 break;
1720 default:
1721 unimplemented:
1722 gemu_log("Unsupported ipc call: %ld (version %d)\n", call, version);
1723 ret = -ENOSYS;
1724 break;
1725 }
1726 return ret;
1727 }
1728
1729 /* kernel structure types definitions */
1730 #define IFNAMSIZ 16
1731
1732 #define STRUCT(name, list...) STRUCT_ ## name,
1733 #define STRUCT_SPECIAL(name) STRUCT_ ## name,
1734 enum {
1735 #include "syscall_types.h"
1736 };
1737 #undef STRUCT
1738 #undef STRUCT_SPECIAL
1739
1740 #define STRUCT(name, list...) const argtype struct_ ## name ## _def[] = { list, TYPE_NULL };
1741 #define STRUCT_SPECIAL(name)
1742 #include "syscall_types.h"
1743 #undef STRUCT
1744 #undef STRUCT_SPECIAL
1745
1746 typedef struct IOCTLEntry {
1747 unsigned int target_cmd;
1748 unsigned int host_cmd;
1749 const char *name;
1750 int access;
1751 const argtype arg_type[5];
1752 } IOCTLEntry;
1753
1754 #define IOC_R 0x0001
1755 #define IOC_W 0x0002
1756 #define IOC_RW (IOC_R | IOC_W)
1757
1758 #define MAX_STRUCT_SIZE 4096
1759
1760 IOCTLEntry ioctl_entries[] = {
1761 #define IOCTL(cmd, access, types...) \
1762 { TARGET_ ## cmd, cmd, #cmd, access, { types } },
1763 #include "ioctls.h"
1764 { 0, 0, },
1765 };
1766
1767 /* ??? Implement proper locking for ioctls. */
1768 static long do_ioctl(long fd, long cmd, long arg)
1769 {
1770 const IOCTLEntry *ie;
1771 const argtype *arg_type;
1772 long ret;
1773 uint8_t buf_temp[MAX_STRUCT_SIZE];
1774 int target_size;
1775 void *argptr;
1776
1777 ie = ioctl_entries;
1778 for(;;) {
1779 if (ie->target_cmd == 0) {
1780 gemu_log("Unsupported ioctl: cmd=0x%04lx\n", cmd);
1781 return -ENOSYS;
1782 }
1783 if (ie->target_cmd == cmd)
1784 break;
1785 ie++;
1786 }
1787 arg_type = ie->arg_type;
1788 #if defined(DEBUG)
1789 gemu_log("ioctl: cmd=0x%04lx (%s)\n", cmd, ie->name);
1790 #endif
1791 switch(arg_type[0]) {
1792 case TYPE_NULL:
1793 /* no argument */
1794 ret = get_errno(ioctl(fd, ie->host_cmd));
1795 break;
1796 case TYPE_PTRVOID:
1797 case TYPE_INT:
1798 /* int argment */
1799 ret = get_errno(ioctl(fd, ie->host_cmd, arg));
1800 break;
1801 case TYPE_PTR:
1802 arg_type++;
1803 target_size = thunk_type_size(arg_type, 0);
1804 switch(ie->access) {
1805 case IOC_R:
1806 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
1807 if (!is_error(ret)) {
1808 argptr = lock_user(arg, target_size, 0);
1809 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
1810 unlock_user(argptr, arg, target_size);
1811 }
1812 break;
1813 case IOC_W:
1814 argptr = lock_user(arg, target_size, 1);
1815 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
1816 unlock_user(argptr, arg, 0);
1817 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
1818 break;
1819 default:
1820 case IOC_RW:
1821 argptr = lock_user(arg, target_size, 1);
1822 thunk_convert(buf_temp, argptr, arg_type, THUNK_HOST);
1823 unlock_user(argptr, arg, 0);
1824 ret = get_errno(ioctl(fd, ie->host_cmd, buf_temp));
1825 if (!is_error(ret)) {
1826 argptr = lock_user(arg, target_size, 0);
1827 thunk_convert(argptr, buf_temp, arg_type, THUNK_TARGET);
1828 unlock_user(argptr, arg, target_size);
1829 }
1830 break;
1831 }
1832 break;
1833 default:
1834 gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n", cmd, arg_type[0]);
1835 ret = -ENOSYS;
1836 break;
1837 }
1838 return ret;
1839 }
1840
1841 bitmask_transtbl iflag_tbl[] = {
1842 { TARGET_IGNBRK, TARGET_IGNBRK, IGNBRK, IGNBRK },
1843 { TARGET_BRKINT, TARGET_BRKINT, BRKINT, BRKINT },
1844 { TARGET_IGNPAR, TARGET_IGNPAR, IGNPAR, IGNPAR },
1845 { TARGET_PARMRK, TARGET_PARMRK, PARMRK, PARMRK },
1846 { TARGET_INPCK, TARGET_INPCK, INPCK, INPCK },
1847 { TARGET_ISTRIP, TARGET_ISTRIP, ISTRIP, ISTRIP },
1848 { TARGET_INLCR, TARGET_INLCR, INLCR, INLCR },
1849 { TARGET_IGNCR, TARGET_IGNCR, IGNCR, IGNCR },
1850 { TARGET_ICRNL, TARGET_ICRNL, ICRNL, ICRNL },
1851 { TARGET_IUCLC, TARGET_IUCLC, IUCLC, IUCLC },
1852 { TARGET_IXON, TARGET_IXON, IXON, IXON },
1853 { TARGET_IXANY, TARGET_IXANY, IXANY, IXANY },
1854 { TARGET_IXOFF, TARGET_IXOFF, IXOFF, IXOFF },
1855 { TARGET_IMAXBEL, TARGET_IMAXBEL, IMAXBEL, IMAXBEL },
1856 { 0, 0, 0, 0 }
1857 };
1858
1859 bitmask_transtbl oflag_tbl[] = {
1860 { TARGET_OPOST, TARGET_OPOST, OPOST, OPOST },
1861 { TARGET_OLCUC, TARGET_OLCUC, OLCUC, OLCUC },
1862 { TARGET_ONLCR, TARGET_ONLCR, ONLCR, ONLCR },
1863 { TARGET_OCRNL, TARGET_OCRNL, OCRNL, OCRNL },
1864 { TARGET_ONOCR, TARGET_ONOCR, ONOCR, ONOCR },
1865 { TARGET_ONLRET, TARGET_ONLRET, ONLRET, ONLRET },
1866 { TARGET_OFILL, TARGET_OFILL, OFILL, OFILL },
1867 { TARGET_OFDEL, TARGET_OFDEL, OFDEL, OFDEL },
1868 { TARGET_NLDLY, TARGET_NL0, NLDLY, NL0 },
1869 { TARGET_NLDLY, TARGET_NL1, NLDLY, NL1 },
1870 { TARGET_CRDLY, TARGET_CR0, CRDLY, CR0 },
1871 { TARGET_CRDLY, TARGET_CR1, CRDLY, CR1 },
1872 { TARGET_CRDLY, TARGET_CR2, CRDLY, CR2 },
1873 { TARGET_CRDLY, TARGET_CR3, CRDLY, CR3 },
1874 { TARGET_TABDLY, TARGET_TAB0, TABDLY, TAB0 },
1875 { TARGET_TABDLY, TARGET_TAB1, TABDLY, TAB1 },
1876 { TARGET_TABDLY, TARGET_TAB2, TABDLY, TAB2 },
1877 { TARGET_TABDLY, TARGET_TAB3, TABDLY, TAB3 },
1878 { TARGET_BSDLY, TARGET_BS0, BSDLY, BS0 },
1879 { TARGET_BSDLY, TARGET_BS1, BSDLY, BS1 },
1880 { TARGET_VTDLY, TARGET_VT0, VTDLY, VT0 },
1881 { TARGET_VTDLY, TARGET_VT1, VTDLY, VT1 },
1882 { TARGET_FFDLY, TARGET_FF0, FFDLY, FF0 },
1883 { TARGET_FFDLY, TARGET_FF1, FFDLY, FF1 },
1884 { 0, 0, 0, 0 }
1885 };
1886
1887 bitmask_transtbl cflag_tbl[] = {
1888 { TARGET_CBAUD, TARGET_B0, CBAUD, B0 },
1889 { TARGET_CBAUD, TARGET_B50, CBAUD, B50 },
1890 { TARGET_CBAUD, TARGET_B75, CBAUD, B75 },
1891 { TARGET_CBAUD, TARGET_B110, CBAUD, B110 },
1892 { TARGET_CBAUD, TARGET_B134, CBAUD, B134 },
1893 { TARGET_CBAUD, TARGET_B150, CBAUD, B150 },
1894 { TARGET_CBAUD, TARGET_B200, CBAUD, B200 },
1895 { TARGET_CBAUD, TARGET_B300, CBAUD, B300 },
1896 { TARGET_CBAUD, TARGET_B600, CBAUD, B600 },
1897 { TARGET_CBAUD, TARGET_B1200, CBAUD, B1200 },
1898 { TARGET_CBAUD, TARGET_B1800, CBAUD, B1800 },
1899 { TARGET_CBAUD, TARGET_B2400, CBAUD, B2400 },
1900 { TARGET_CBAUD, TARGET_B4800, CBAUD, B4800 },
1901 { TARGET_CBAUD, TARGET_B9600, CBAUD, B9600 },
1902 { TARGET_CBAUD, TARGET_B19200, CBAUD, B19200 },
1903 { TARGET_CBAUD, TARGET_B38400, CBAUD, B38400 },
1904 { TARGET_CBAUD, TARGET_B57600, CBAUD, B57600 },
1905 { TARGET_CBAUD, TARGET_B115200, CBAUD, B115200 },
1906 { TARGET_CBAUD, TARGET_B230400, CBAUD, B230400 },
1907 { TARGET_CBAUD, TARGET_B460800, CBAUD, B460800 },
1908 { TARGET_CSIZE, TARGET_CS5, CSIZE, CS5 },
1909 { TARGET_CSIZE, TARGET_CS6, CSIZE, CS6 },
1910 { TARGET_CSIZE, TARGET_CS7, CSIZE, CS7 },
1911 { TARGET_CSIZE, TARGET_CS8, CSIZE, CS8 },
1912 { TARGET_CSTOPB, TARGET_CSTOPB, CSTOPB, CSTOPB },
1913 { TARGET_CREAD, TARGET_CREAD, CREAD, CREAD },
1914 { TARGET_PARENB, TARGET_PARENB, PARENB, PARENB },
1915 { TARGET_PARODD, TARGET_PARODD, PARODD, PARODD },
1916 { TARGET_HUPCL, TARGET_HUPCL, HUPCL, HUPCL },
1917 { TARGET_CLOCAL, TARGET_CLOCAL, CLOCAL, CLOCAL },
1918 { TARGET_CRTSCTS, TARGET_CRTSCTS, CRTSCTS, CRTSCTS },
1919 { 0, 0, 0, 0 }
1920 };
1921
1922 bitmask_transtbl lflag_tbl[] = {
1923 { TARGET_ISIG, TARGET_ISIG, ISIG, ISIG },
1924 { TARGET_ICANON, TARGET_ICANON, ICANON, ICANON },
1925 { TARGET_XCASE, TARGET_XCASE, XCASE, XCASE },
1926 { TARGET_ECHO, TARGET_ECHO, ECHO, ECHO },
1927 { TARGET_ECHOE, TARGET_ECHOE, ECHOE, ECHOE },
1928 { TARGET_ECHOK, TARGET_ECHOK, ECHOK, ECHOK },
1929 { TARGET_ECHONL, TARGET_ECHONL, ECHONL, ECHONL },
1930 { TARGET_NOFLSH, TARGET_NOFLSH, NOFLSH, NOFLSH },
1931 { TARGET_TOSTOP, TARGET_TOSTOP, TOSTOP, TOSTOP },
1932 { TARGET_ECHOCTL, TARGET_ECHOCTL, ECHOCTL, ECHOCTL },
1933 { TARGET_ECHOPRT, TARGET_ECHOPRT, ECHOPRT, ECHOPRT },
1934 { TARGET_ECHOKE, TARGET_ECHOKE, ECHOKE, ECHOKE },
1935 { TARGET_FLUSHO, TARGET_FLUSHO, FLUSHO, FLUSHO },
1936 { TARGET_PENDIN, TARGET_PENDIN, PENDIN, PENDIN },
1937 { TARGET_IEXTEN, TARGET_IEXTEN, IEXTEN, IEXTEN },
1938 { 0, 0, 0, 0 }
1939 };
1940
1941 static void target_to_host_termios (void *dst, const void *src)
1942 {
1943 struct host_termios *host = dst;
1944 const struct target_termios *target = src;
1945
1946 host->c_iflag =
1947 target_to_host_bitmask(tswap32(target->c_iflag), iflag_tbl);
1948 host->c_oflag =
1949 target_to_host_bitmask(tswap32(target->c_oflag), oflag_tbl);
1950 host->c_cflag =
1951 target_to_host_bitmask(tswap32(target->c_cflag), cflag_tbl);
1952 host->c_lflag =
1953 target_to_host_bitmask(tswap32(target->c_lflag), lflag_tbl);
1954 host->c_line = target->c_line;
1955
1956 host->c_cc[VINTR] = target->c_cc[TARGET_VINTR];
1957 host->c_cc[VQUIT] = target->c_cc[TARGET_VQUIT];
1958 host->c_cc[VERASE] = target->c_cc[TARGET_VERASE];
1959 host->c_cc[VKILL] = target->c_cc[TARGET_VKILL];
1960 host->c_cc[VEOF] = target->c_cc[TARGET_VEOF];
1961 host->c_cc[VTIME] = target->c_cc[TARGET_VTIME];
1962 host->c_cc[VMIN] = target->c_cc[TARGET_VMIN];
1963 host->c_cc[VSWTC] = target->c_cc[TARGET_VSWTC];
1964 host->c_cc[VSTART] = target->c_cc[TARGET_VSTART];
1965 host->c_cc[VSTOP] = target->c_cc[TARGET_VSTOP];
1966 host->c_cc[VSUSP] = target->c_cc[TARGET_VSUSP];
1967 host->c_cc[VEOL] = target->c_cc[TARGET_VEOL];
1968 host->c_cc[VREPRINT] = target->c_cc[TARGET_VREPRINT];
1969 host->c_cc[VDISCARD] = target->c_cc[TARGET_VDISCARD];
1970 host->c_cc[VWERASE] = target->c_cc[TARGET_VWERASE];
1971 host->c_cc[VLNEXT] = target->c_cc[TARGET_VLNEXT];
1972 host->c_cc[VEOL2] = target->c_cc[TARGET_VEOL2];
1973 }
1974
1975 static void host_to_target_termios (void *dst, const void *src)
1976 {
1977 struct target_termios *target = dst;
1978 const struct host_termios *host = src;
1979
1980 target->c_iflag =
1981 tswap32(host_to_target_bitmask(host->c_iflag, iflag_tbl));
1982 target->c_oflag =
1983 tswap32(host_to_target_bitmask(host->c_oflag, oflag_tbl));
1984 target->c_cflag =
1985 tswap32(host_to_target_bitmask(host->c_cflag, cflag_tbl));
1986 target->c_lflag =
1987 tswap32(host_to_target_bitmask(host->c_lflag, lflag_tbl));
1988 target->c_line = host->c_line;
1989
1990 target->c_cc[TARGET_VINTR] = host->c_cc[VINTR];
1991 target->c_cc[TARGET_VQUIT] = host->c_cc[VQUIT];
1992 target->c_cc[TARGET_VERASE] = host->c_cc[VERASE];
1993 target->c_cc[TARGET_VKILL] = host->c_cc[VKILL];
1994 target->c_cc[TARGET_VEOF] = host->c_cc[VEOF];
1995 target->c_cc[TARGET_VTIME] = host->c_cc[VTIME];
1996 target->c_cc[TARGET_VMIN] = host->c_cc[VMIN];
1997 target->c_cc[TARGET_VSWTC] = host->c_cc[VSWTC];
1998 target->c_cc[TARGET_VSTART] = host->c_cc[VSTART];
1999 target->c_cc[TARGET_VSTOP] = host->c_cc[VSTOP];
2000 target->c_cc[TARGET_VSUSP] = host->c_cc[VSUSP];
2001 target->c_cc[TARGET_VEOL] = host->c_cc[VEOL];
2002 target->c_cc[TARGET_VREPRINT] = host->c_cc[VREPRINT];
2003 target->c_cc[TARGET_VDISCARD] = host->c_cc[VDISCARD];
2004 target->c_cc[TARGET_VWERASE] = host->c_cc[VWERASE];
2005 target->c_cc[TARGET_VLNEXT] = host->c_cc[VLNEXT];
2006 target->c_cc[TARGET_VEOL2] = host->c_cc[VEOL2];
2007 }
2008
2009 StructEntry struct_termios_def = {
2010 .convert = { host_to_target_termios, target_to_host_termios },
2011 .size = { sizeof(struct target_termios), sizeof(struct host_termios) },
2012 .align = { __alignof__(struct target_termios), __alignof__(struct host_termios) },
2013 };
2014
2015 static bitmask_transtbl mmap_flags_tbl[] = {
2016 { TARGET_MAP_SHARED, TARGET_MAP_SHARED, MAP_SHARED, MAP_SHARED },
2017 { TARGET_MAP_PRIVATE, TARGET_MAP_PRIVATE, MAP_PRIVATE, MAP_PRIVATE },
2018 { TARGET_MAP_FIXED, TARGET_MAP_FIXED, MAP_FIXED, MAP_FIXED },
2019 { TARGET_MAP_ANONYMOUS, TARGET_MAP_ANONYMOUS, MAP_ANONYMOUS, MAP_ANONYMOUS },
2020 { TARGET_MAP_GROWSDOWN, TARGET_MAP_GROWSDOWN, MAP_GROWSDOWN, MAP_GROWSDOWN },
2021 { TARGET_MAP_DENYWRITE, TARGET_MAP_DENYWRITE, MAP_DENYWRITE, MAP_DENYWRITE },
2022 { TARGET_MAP_EXECUTABLE, TARGET_MAP_EXECUTABLE, MAP_EXECUTABLE, MAP_EXECUTABLE },
2023 { TARGET_MAP_LOCKED, TARGET_MAP_LOCKED, MAP_LOCKED, MAP_LOCKED },
2024 { 0, 0, 0, 0 }
2025 };
2026
2027 static bitmask_transtbl fcntl_flags_tbl[] = {
2028 { TARGET_O_ACCMODE, TARGET_O_WRONLY, O_ACCMODE, O_WRONLY, },
2029 { TARGET_O_ACCMODE, TARGET_O_RDWR, O_ACCMODE, O_RDWR, },
2030 { TARGET_O_CREAT, TARGET_O_CREAT, O_CREAT, O_CREAT, },
2031 { TARGET_O_EXCL, TARGET_O_EXCL, O_EXCL, O_EXCL, },
2032 { TARGET_O_NOCTTY, TARGET_O_NOCTTY, O_NOCTTY, O_NOCTTY, },
2033 { TARGET_O_TRUNC, TARGET_O_TRUNC, O_TRUNC, O_TRUNC, },
2034 { TARGET_O_APPEND, TARGET_O_APPEND, O_APPEND, O_APPEND, },
2035 { TARGET_O_NONBLOCK, TARGET_O_NONBLOCK, O_NONBLOCK, O_NONBLOCK, },
2036 { TARGET_O_SYNC, TARGET_O_SYNC, O_SYNC, O_SYNC, },
2037 { TARGET_FASYNC, TARGET_FASYNC, FASYNC, FASYNC, },
2038 { TARGET_O_DIRECTORY, TARGET_O_DIRECTORY, O_DIRECTORY, O_DIRECTORY, },
2039 { TARGET_O_NOFOLLOW, TARGET_O_NOFOLLOW, O_NOFOLLOW, O_NOFOLLOW, },
2040 { TARGET_O_LARGEFILE, TARGET_O_LARGEFILE, O_LARGEFILE, O_LARGEFILE, },
2041 #if defined(O_DIRECT)
2042 { TARGET_O_DIRECT, TARGET_O_DIRECT, O_DIRECT, O_DIRECT, },
2043 #endif
2044 { 0, 0, 0, 0 }
2045 };
2046
2047 #if defined(TARGET_I386)
2048
2049 /* NOTE: there is really one LDT for all the threads */
2050 uint8_t *ldt_table;
2051
2052 static int read_ldt(target_ulong ptr, unsigned long bytecount)
2053 {
2054 int size;
2055 void *p;
2056
2057 if (!ldt_table)
2058 return 0;
2059 size = TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE;
2060 if (size > bytecount)
2061 size = bytecount;
2062 p = lock_user(ptr, size, 0);
2063 /* ??? Shoudl this by byteswapped? */
2064 memcpy(p, ldt_table, size);
2065 unlock_user(p, ptr, size);
2066 return size;
2067 }
2068
2069 /* XXX: add locking support */
2070 static int write_ldt(CPUX86State *env,
2071 target_ulong ptr, unsigned long bytecount, int oldmode)
2072 {
2073 struct target_modify_ldt_ldt_s ldt_info;
2074 struct target_modify_ldt_ldt_s *target_ldt_info;
2075 int seg_32bit, contents, read_exec_only, limit_in_pages;
2076 int seg_not_present, useable;
2077 uint32_t *lp, entry_1, entry_2;
2078
2079 if (bytecount != sizeof(ldt_info))
2080 return -EINVAL;
2081 lock_user_struct(target_ldt_info, ptr, 1);
2082 ldt_info.entry_number = tswap32(target_ldt_info->entry_number);
2083 ldt_info.base_addr = tswapl(target_ldt_info->base_addr);
2084 ldt_info.limit = tswap32(target_ldt_info->limit);
2085 ldt_info.flags = tswap32(target_ldt_info->flags);
2086 unlock_user_struct(target_ldt_info, ptr, 0);
2087
2088 if (ldt_info.entry_number >= TARGET_LDT_ENTRIES)
2089 return -EINVAL;
2090 seg_32bit = ldt_info.flags & 1;
2091 contents = (ldt_info.flags >> 1) & 3;
2092 read_exec_only = (ldt_info.flags >> 3) & 1;
2093 limit_in_pages = (ldt_info.flags >> 4) & 1;
2094 seg_not_present = (ldt_info.flags >> 5) & 1;
2095 useable = (ldt_info.flags >> 6) & 1;
2096
2097 if (contents == 3) {
2098 if (oldmode)
2099 return -EINVAL;
2100 if (seg_not_present == 0)
2101 return -EINVAL;
2102 }
2103 /* allocate the LDT */
2104 if (!ldt_table) {
2105 ldt_table = malloc(TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
2106 if (!ldt_table)
2107 return -ENOMEM;
2108 memset(ldt_table, 0, TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE);
2109 env->ldt.base = h2g(ldt_table);
2110 env->ldt.limit = 0xffff;
2111 }
2112
2113 /* NOTE: same code as Linux kernel */
2114 /* Allow LDTs to be cleared by the user. */
2115 if (ldt_info.base_addr == 0 && ldt_info.limit == 0) {
2116 if (oldmode ||
2117 (contents == 0 &&
2118 read_exec_only == 1 &&
2119 seg_32bit == 0 &&
2120 limit_in_pages == 0 &&
2121 seg_not_present == 1 &&
2122 useable == 0 )) {
2123 entry_1 = 0;
2124 entry_2 = 0;
2125 goto install;
2126 }
2127 }
2128
2129 entry_1 = ((ldt_info.base_addr & 0x0000ffff) << 16) |
2130 (ldt_info.limit & 0x0ffff);
2131 entry_2 = (ldt_info.base_addr & 0xff000000) |
2132 ((ldt_info.base_addr & 0x00ff0000) >> 16) |
2133 (ldt_info.limit & 0xf0000) |
2134 ((read_exec_only ^ 1) << 9) |
2135 (contents << 10) |
2136 ((seg_not_present ^ 1) << 15) |
2137 (seg_32bit << 22) |
2138 (limit_in_pages << 23) |
2139 0x7000;
2140 if (!oldmode)
2141 entry_2 |= (useable << 20);
2142
2143 /* Install the new entry ... */
2144 install:
2145 lp = (uint32_t *)(ldt_table + (ldt_info.entry_number << 3));
2146 lp[0] = tswap32(entry_1);
2147 lp[1] = tswap32(entry_2);
2148 return 0;
2149 }
2150
2151 /* specific and weird i386 syscalls */
2152 int do_modify_ldt(CPUX86State *env, int func, target_ulong ptr, unsigned long bytecount)
2153 {
2154 int ret = -ENOSYS;
2155
2156 switch (func) {
2157 case 0:
2158 ret = read_ldt(ptr, bytecount);
2159 break;
2160 case 1:
2161 ret = write_ldt(env, ptr, bytecount, 1);
2162 break;
2163 case 0x11:
2164 ret = write_ldt(env, ptr, bytecount, 0);
2165 break;
2166 }
2167 return ret;
2168 }
2169
2170 #endif /* defined(TARGET_I386) */
2171
2172 /* this stack is the equivalent of the kernel stack associated with a
2173 thread/process */
2174 #define NEW_STACK_SIZE 8192
2175
2176 static int clone_func(void *arg)
2177 {
2178 CPUState *env = arg;
2179 cpu_loop(env);
2180 /* never exits */
2181 return 0;
2182 }
2183
2184 int do_fork(CPUState *env, unsigned int flags, unsigned long newsp)
2185 {
2186 int ret;
2187 TaskState *ts;
2188 uint8_t *new_stack;
2189 CPUState *new_env;
2190
2191 if (flags & CLONE_VM) {
2192 ts = malloc(sizeof(TaskState) + NEW_STACK_SIZE);
2193 memset(ts, 0, sizeof(TaskState));
2194 new_stack = ts->stack;
2195 ts->used = 1;
2196 /* add in task state list */
2197 ts->next = first_task_state;
2198 first_task_state = ts;
2199 /* we create a new CPU instance. */
2200 new_env = cpu_copy(env);
2201 #if defined(TARGET_I386)
2202 if (!newsp)
2203 newsp = env->regs[R_ESP];
2204 new_env->regs[R_ESP] = newsp;
2205 new_env->regs[R_EAX] = 0;
2206 #elif defined(TARGET_ARM)
2207 if (!newsp)
2208 newsp = env->regs[13];
2209 new_env->regs[13] = newsp;
2210 new_env->regs[0] = 0;
2211 #elif defined(TARGET_SPARC)
2212 if (!newsp)
2213 newsp = env->regwptr[22];
2214 new_env->regwptr[22] = newsp;
2215 new_env->regwptr[0] = 0;
2216 /* XXXXX */
2217 printf ("HELPME: %s:%d\n", __FILE__, __LINE__);
2218 #elif defined(TARGET_M68K)
2219 if (!newsp)
2220 newsp = env->aregs[7];
2221 new_env->aregs[7] = newsp;
2222 new_env->dregs[0] = 0;
2223 /* ??? is this sufficient? */
2224 #elif defined(TARGET_MIPS)
2225 if (!newsp)
2226 newsp = env->gpr[29][env->current_tc];
2227 new_env->gpr[29][env->current_tc] = newsp;
2228 #elif defined(TARGET_PPC)
2229 if (!newsp)
2230 newsp = env->gpr[1];
2231 new_env->gpr[1] = newsp;
2232 {
2233 int i;
2234 for (i = 7; i < 32; i++)
2235 new_env->gpr[i] = 0;
2236 }
2237 #elif defined(TARGET_SH4)
2238 if (!newsp)
2239 newsp = env->gregs[15];
2240 new_env->gregs[15] = newsp;
2241 /* XXXXX */
2242 #elif defined(TARGET_ALPHA)
2243 if (!newsp)
2244 newsp = env->ir[30];
2245 new_env->ir[30] = newsp;
2246 /* ? */
2247 {
2248 int i;
2249 for (i = 7; i < 30; i++)
2250 new_env->ir[i] = 0;
2251 }
2252 #else
2253 #error unsupported target CPU
2254 #endif
2255 new_env->opaque = ts;
2256 #ifdef __ia64__
2257 ret = __clone2(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
2258 #else
2259 ret = clone(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
2260 #endif
2261 } else {
2262 /* if no CLONE_VM, we consider it is a fork */
2263 if ((flags & ~CSIGNAL) != 0)
2264 return -EINVAL;
2265 ret = fork();
2266 }
2267 return ret;
2268 }
2269
2270 static long do_fcntl(int fd, int cmd, target_ulong arg)
2271 {
2272 struct flock fl;
2273 struct target_flock *target_fl;
2274 struct flock64 fl64;
2275 struct target_flock64 *target_fl64;
2276 long ret;
2277
2278 switch(cmd) {
2279 case TARGET_F_GETLK:
2280 lock_user_struct(target_fl, arg, 1);
2281 fl.l_type = tswap16(target_fl->l_type);
2282 fl.l_whence = tswap16(target_fl->l_whence);
2283 fl.l_start = tswapl(target_fl->l_start);
2284 fl.l_len = tswapl(target_fl->l_len);
2285 fl.l_pid = tswapl(target_fl->l_pid);
2286 unlock_user_struct(target_fl, arg, 0);
2287 ret = fcntl(fd, cmd, &fl);
2288 if (ret == 0) {
2289 lock_user_struct(target_fl, arg, 0);
2290 target_fl->l_type = tswap16(fl.l_type);
2291 target_fl->l_whence = tswap16(fl.l_whence);
2292 target_fl->l_start = tswapl(fl.l_start);
2293 target_fl->l_len = tswapl(fl.l_len);
2294 target_fl->l_pid = tswapl(fl.l_pid);
2295 unlock_user_struct(target_fl, arg, 1);
2296 }
2297 break;
2298
2299 case TARGET_F_SETLK:
2300 case TARGET_F_SETLKW:
2301 lock_user_struct(target_fl, arg, 1);
2302 fl.l_type = tswap16(target_fl->l_type);
2303 fl.l_whence = tswap16(target_fl->l_whence);
2304 fl.l_start = tswapl(target_fl->l_start);
2305 fl.l_len = tswapl(target_fl->l_len);
2306 fl.l_pid = tswapl(target_fl->l_pid);
2307 unlock_user_struct(target_fl, arg, 0);
2308 ret = fcntl(fd, cmd, &fl);
2309 break;
2310
2311 case TARGET_F_GETLK64:
2312 lock_user_struct(target_fl64, arg, 1);
2313 fl64.l_type = tswap16(target_fl64->l_type) >> 1;
2314 fl64.l_whence = tswap16(target_fl64->l_whence);
2315 fl64.l_start = tswapl(target_fl64->l_start);
2316 fl64.l_len = tswapl(target_fl64->l_len);
2317 fl64.l_pid = tswap16(target_fl64->l_pid);
2318 unlock_user_struct(target_fl64, arg, 0);
2319 ret = fcntl(fd, cmd >> 1, &fl64);
2320 if (ret == 0) {
2321 lock_user_struct(target_fl64, arg, 0);
2322 target_fl64->l_type = tswap16(fl64.l_type) >> 1;
2323 target_fl64->l_whence = tswap16(fl64.l_whence);
2324 target_fl64->l_start = tswapl(fl64.l_start);
2325 target_fl64->l_len = tswapl(fl64.l_len);
2326 target_fl64->l_pid = tswapl(fl64.l_pid);
2327 unlock_user_struct(target_fl64, arg, 1);
2328 }
2329 break;
2330 case TARGET_F_SETLK64:
2331 case TARGET_F_SETLKW64:
2332 lock_user_struct(target_fl64, arg, 1);
2333 fl64.l_type = tswap16(target_fl64->l_type) >> 1;
2334 fl64.l_whence = tswap16(target_fl64->l_whence);
2335 fl64.l_start = tswapl(target_fl64->l_start);
2336 fl64.l_len = tswapl(target_fl64->l_len);
2337 fl64.l_pid = tswap16(target_fl64->l_pid);
2338 unlock_user_struct(target_fl64, arg, 0);
2339 ret = fcntl(fd, cmd >> 1, &fl64);
2340 break;
2341
2342 case F_GETFL:
2343 ret = fcntl(fd, cmd, arg);
2344 ret = host_to_target_bitmask(ret, fcntl_flags_tbl);
2345 break;
2346
2347 case F_SETFL:
2348 ret = fcntl(fd, cmd, target_to_host_bitmask(arg, fcntl_flags_tbl));
2349 break;
2350
2351 default:
2352 ret = fcntl(fd, cmd, arg);
2353 break;
2354 }
2355 return ret;
2356 }
2357
2358 #ifdef USE_UID16
2359
2360 static inline int high2lowuid(int uid)
2361 {
2362 if (uid > 65535)
2363 return 65534;
2364 else
2365 return uid;
2366 }
2367
2368 static inline int high2lowgid(int gid)
2369 {
2370 if (gid > 65535)
2371 return 65534;
2372 else
2373 return gid;
2374 }
2375
2376 static inline int low2highuid(int uid)
2377 {
2378 if ((int16_t)uid == -1)
2379 return -1;
2380 else
2381 return uid;
2382 }
2383
2384 static inline int low2highgid(int gid)
2385 {
2386 if ((int16_t)gid == -1)
2387 return -1;
2388 else
2389 return gid;
2390 }
2391
2392 #endif /* USE_UID16 */
2393
2394 void syscall_init(void)
2395 {
2396 IOCTLEntry *ie;
2397 const argtype *arg_type;
2398 int size;
2399
2400 #define STRUCT(name, list...) thunk_register_struct(STRUCT_ ## name, #name, struct_ ## name ## _def);
2401 #define STRUCT_SPECIAL(name) thunk_register_struct_direct(STRUCT_ ## name, #name, &struct_ ## name ## _def);
2402 #include "syscall_types.h"
2403 #undef STRUCT
2404 #undef STRUCT_SPECIAL
2405
2406 /* we patch the ioctl size if necessary. We rely on the fact that
2407 no ioctl has all the bits at '1' in the size field */
2408 ie = ioctl_entries;
2409 while (ie->target_cmd != 0) {
2410 if (((ie->target_cmd >> TARGET_IOC_SIZESHIFT) & TARGET_IOC_SIZEMASK) ==
2411 TARGET_IOC_SIZEMASK) {
2412 arg_type = ie->arg_type;
2413 if (arg_type[0] != TYPE_PTR) {
2414 fprintf(stderr, "cannot patch size for ioctl 0x%x\n",
2415 ie->target_cmd);
2416 exit(1);
2417 }
2418 arg_type++;
2419 size = thunk_type_size(arg_type, 0);
2420 ie->target_cmd = (ie->target_cmd &
2421 ~(TARGET_IOC_SIZEMASK << TARGET_IOC_SIZESHIFT)) |
2422 (size << TARGET_IOC_SIZESHIFT);
2423 }
2424 /* automatic consistency check if same arch */
2425 #if defined(__i386__) && defined(TARGET_I386)
2426 if (ie->target_cmd != ie->host_cmd) {
2427 fprintf(stderr, "ERROR: ioctl: target=0x%x host=0x%x\n",
2428 ie->target_cmd, ie->host_cmd);
2429 }
2430 #endif
2431 ie++;
2432 }
2433 }
2434
2435 static inline uint64_t target_offset64(uint32_t word0, uint32_t word1)
2436 {
2437 #ifdef TARGET_WORDS_BIG_ENDIAN
2438 return ((uint64_t)word0 << 32) | word1;
2439 #else
2440 return ((uint64_t)word1 << 32) | word0;
2441 #endif
2442 }
2443
2444 #ifdef TARGET_NR_truncate64
2445 static inline long target_truncate64(void *cpu_env, const char *arg1,
2446 long arg2, long arg3, long arg4)
2447 {
2448 #ifdef TARGET_ARM
2449 if (((CPUARMState *)cpu_env)->eabi)
2450 {
2451 arg2 = arg3;
2452 arg3 = arg4;
2453 }
2454 #endif
2455 return get_errno(truncate64(arg1, target_offset64(arg2, arg3)));
2456 }
2457 #endif
2458
2459 #ifdef TARGET_NR_ftruncate64
2460 static inline long target_ftruncate64(void *cpu_env, long arg1, long arg2,
2461 long arg3, long arg4)
2462 {
2463 #ifdef TARGET_ARM
2464 if (((CPUARMState *)cpu_env)->eabi)
2465 {
2466 arg2 = arg3;
2467 arg3 = arg4;
2468 }
2469 #endif
2470 return get_errno(ftruncate64(arg1, target_offset64(arg2, arg3)));
2471 }
2472 #endif
2473
2474 static inline void target_to_host_timespec(struct timespec *host_ts,
2475 target_ulong target_addr)
2476 {
2477 struct target_timespec *target_ts;
2478
2479 lock_user_struct(target_ts, target_addr, 1);
2480 host_ts->tv_sec = tswapl(target_ts->tv_sec);
2481 host_ts->tv_nsec = tswapl(target_ts->tv_nsec);
2482 unlock_user_struct(target_ts, target_addr, 0);
2483 }
2484
2485 static inline void host_to_target_timespec(target_ulong target_addr,
2486 struct timespec *host_ts)
2487 {
2488 struct target_timespec *target_ts;
2489
2490 lock_user_struct(target_ts, target_addr, 0);
2491 target_ts->tv_sec = tswapl(host_ts->tv_sec);
2492 target_ts->tv_nsec = tswapl(host_ts->tv_nsec);
2493 unlock_user_struct(target_ts, target_addr, 1);
2494 }
2495
2496 long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3,
2497 long arg4, long arg5, long arg6)
2498 {
2499 long ret;
2500 struct stat st;
2501 struct statfs stfs;
2502 void *p;
2503
2504 #ifdef DEBUG
2505 gemu_log("syscall %d", num);
2506 #endif
2507 switch(num) {
2508 case TARGET_NR_exit:
2509 #ifdef HAVE_GPROF
2510 _mcleanup();
2511 #endif
2512 gdb_exit(cpu_env, arg1);
2513 /* XXX: should free thread stack and CPU env */
2514 _exit(arg1);
2515 ret = 0; /* avoid warning */
2516 break;
2517 case TARGET_NR_read:
2518 page_unprotect_range(arg2, arg3);
2519 p = lock_user(arg2, arg3, 0);
2520 ret = get_errno(read(arg1, p, arg3));
2521 unlock_user(p, arg2, ret);
2522 break;
2523 case TARGET_NR_write:
2524 p = lock_user(arg2, arg3, 1);
2525 ret = get_errno(write(arg1, p, arg3));
2526 unlock_user(p, arg2, 0);
2527 break;
2528 case TARGET_NR_open:
2529 p = lock_user_string(arg1);
2530 ret = get_errno(open(path(p),
2531 target_to_host_bitmask(arg2, fcntl_flags_tbl),
2532 arg3));
2533 unlock_user(p, arg1, 0);
2534 break;
2535 #if defined(TARGET_NR_openat) && defined(__NR_openat)
2536 case TARGET_NR_openat:
2537 if (!arg2) {
2538 ret = -EFAULT;
2539 goto fail;
2540 }
2541 p = lock_user_string(arg2);
2542 if (!access_ok(VERIFY_READ, p, 1))
2543 ret = -EFAULT;
2544 else
2545 ret = get_errno(sys_openat(arg1,
2546 path(p),
2547 target_to_host_bitmask(arg3, fcntl_flags_tbl),
2548 arg4));
2549 if (p)
2550 unlock_user(p, arg2, 0);
2551 break;
2552 #endif
2553 case TARGET_NR_close:
2554 ret = get_errno(close(arg1));
2555 break;
2556 case TARGET_NR_brk:
2557 ret = do_brk(arg1);
2558 break;
2559 case TARGET_NR_fork:
2560 ret = get_errno(do_fork(cpu_env, SIGCHLD, 0));
2561 break;
2562 #ifdef TARGET_NR_waitpid
2563 case TARGET_NR_waitpid:
2564 {
2565 int status;
2566 ret = get_errno(waitpid(arg1, &status, arg3));
2567 if (!is_error(ret) && arg2)
2568 tput32(arg2, status);
2569 }
2570 break;
2571 #endif
2572 #ifdef TARGET_NR_creat /* not on alpha */
2573 case TARGET_NR_creat:
2574 p = lock_user_string(arg1);
2575 ret = get_errno(creat(p, arg2));
2576 unlock_user(p, arg1, 0);
2577 break;
2578 #endif
2579 case TARGET_NR_link:
2580 {
2581 void * p2;
2582 p = lock_user_string(arg1);
2583 p2 = lock_user_string(arg2);
2584 ret = get_errno(link(p, p2));
2585 unlock_user(p2, arg2, 0);
2586 unlock_user(p, arg1, 0);
2587 }
2588 break;
2589 #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
2590 case TARGET_NR_linkat:
2591 if (!arg2 || !arg4) {
2592 ret = -EFAULT;
2593 goto fail;
2594 }
2595 {
2596 void * p2 = NULL;
2597 p = lock_user_string(arg2);
2598 p2 = lock_user_string(arg4);
2599 if (!access_ok(VERIFY_READ, p, 1)
2600 || !access_ok(VERIFY_READ, p2, 1))
2601 ret = -EFAULT;
2602 else
2603 ret = get_errno(sys_linkat(arg1, p, arg3, p2, arg5));
2604 if (p2)
2605 unlock_user(p, arg2, 0);
2606 if (p)
2607 unlock_user(p2, arg4, 0);
2608 }
2609 break;
2610 #endif
2611 case TARGET_NR_unlink:
2612 p = lock_user_string(arg1);
2613 ret = get_errno(unlink(p));
2614 unlock_user(p, arg1, 0);
2615 break;
2616 #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
2617 case TARGET_NR_unlinkat:
2618 if (!arg2) {
2619 ret = -EFAULT;
2620 goto fail;
2621 }
2622 p = lock_user_string(arg2);
2623 if (!access_ok(VERIFY_READ, p, 1))
2624 ret = -EFAULT;
2625 else
2626 ret = get_errno(sys_unlinkat(arg1, p, arg3));
2627 if (p)
2628 unlock_user(p, arg2, 0);
2629 break;
2630 #endif
2631 case TARGET_NR_execve:
2632 {
2633 char **argp, **envp;
2634 int argc, envc;
2635 target_ulong gp;
2636 target_ulong guest_argp;
2637 target_ulong guest_envp;
2638 target_ulong addr;
2639 char **q;
2640
2641 argc = 0;
2642 guest_argp = arg2;
2643 for (gp = guest_argp; tgetl(gp); gp++)
2644 argc++;
2645 envc = 0;
2646 guest_envp = arg3;
2647 for (gp = guest_envp; tgetl(gp); gp++)
2648 envc++;
2649
2650 argp = alloca((argc + 1) * sizeof(void *));
2651 envp = alloca((envc + 1) * sizeof(void *));
2652
2653 for (gp = guest_argp, q = argp; ;
2654 gp += sizeof(target_ulong), q++) {
2655 addr = tgetl(gp);
2656 if (!addr)
2657 break;
2658 *q = lock_user_string(addr);
2659 }
2660 *q = NULL;
2661
2662 for (gp = guest_envp, q = envp; ;
2663 gp += sizeof(target_ulong), q++) {
2664 addr = tgetl(gp);
2665 if (!addr)
2666 break;
2667 *q = lock_user_string(addr);
2668 }
2669 *q = NULL;
2670
2671 p = lock_user_string(arg1);
2672 ret = get_errno(execve(p, argp, envp));
2673 unlock_user(p, arg1, 0);
2674
2675 for (gp = guest_argp, q = argp; *q;
2676 gp += sizeof(target_ulong), q++) {
2677 addr = tgetl(gp);
2678 unlock_user(*q, addr, 0);
2679 }
2680 for (gp = guest_envp, q = envp; *q;
2681 gp += sizeof(target_ulong), q++) {
2682 addr = tgetl(gp);
2683 unlock_user(*q, addr, 0);
2684 }
2685 }
2686 break;
2687 case TARGET_NR_chdir:
2688 p = lock_user_string(arg1);
2689 ret = get_errno(chdir(p));
2690 unlock_user(p, arg1, 0);
2691 break;
2692 #ifdef TARGET_NR_time
2693 case TARGET_NR_time:
2694 {
2695 time_t host_time;
2696 ret = get_errno(time(&host_time));
2697 if (!is_error(ret) && arg1)
2698 tputl(arg1, host_time);
2699 }
2700 break;
2701 #endif
2702 case TARGET_NR_mknod:
2703 p = lock_user_string(arg1);
2704 ret = get_errno(mknod(p, arg2, arg3));
2705 unlock_user(p, arg1, 0);
2706 break;
2707 #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
2708 case TARGET_NR_mknodat:
2709 if (!arg2) {
2710 ret = -EFAULT;
2711 goto fail;
2712 }
2713 p = lock_user_string(arg2);
2714 if (!access_ok(VERIFY_READ, p, 1))
2715 ret = -EFAULT;
2716 else
2717 ret = get_errno(sys_mknodat(arg1, p, arg3, arg4));
2718 if (p)
2719 unlock_user(p, arg2, 0);
2720 break;
2721 #endif
2722 case TARGET_NR_chmod:
2723 p = lock_user_string(arg1);
2724 ret = get_errno(chmod(p, arg2));
2725 unlock_user(p, arg1, 0);
2726 break;
2727 #ifdef TARGET_NR_break
2728 case TARGET_NR_break:
2729 goto unimplemented;
2730 #endif
2731 #ifdef TARGET_NR_oldstat
2732 case TARGET_NR_oldstat:
2733 goto unimplemented;
2734 #endif
2735 case TARGET_NR_lseek:
2736 ret = get_errno(lseek(arg1, arg2, arg3));
2737 break;
2738 #ifdef TARGET_NR_getxpid
2739 case TARGET_NR_getxpid:
2740 #else
2741 case TARGET_NR_getpid:
2742 #endif
2743 ret = get_errno(getpid());
2744 break;
2745 case TARGET_NR_mount:
2746 {
2747 /* need to look at the data field */
2748 void *p2, *p3;
2749 p = lock_user_string(arg1);
2750 p2 = lock_user_string(arg2);
2751 p3 = lock_user_string(arg3);
2752 ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, (const void *)arg5));
2753 unlock_user(p, arg1, 0);
2754 unlock_user(p2, arg2, 0);
2755 unlock_user(p3, arg3, 0);
2756 break;
2757 }
2758 #ifdef TARGET_NR_umount
2759 case TARGET_NR_umount:
2760 p = lock_user_string(arg1);
2761 ret = get_errno(umount(p));
2762 unlock_user(p, arg1, 0);
2763 break;
2764 #endif
2765 #ifdef TARGET_NR_stime /* not on alpha */
2766 case TARGET_NR_stime:
2767 {
2768 time_t host_time;
2769 host_time = tgetl(arg1);
2770 ret = get_errno(stime(&host_time));
2771 }
2772 break;
2773 #endif
2774 case TARGET_NR_ptrace:
2775 goto unimplemented;
2776 #ifdef TARGET_NR_alarm /* not on alpha */
2777 case TARGET_NR_alarm:
2778 ret = alarm(arg1);
2779 break;
2780 #endif
2781 #ifdef TARGET_NR_oldfstat
2782 case TARGET_NR_oldfstat:
2783 goto unimplemented;
2784 #endif
2785 #ifdef TARGET_NR_pause /* not on alpha */
2786 case TARGET_NR_pause:
2787 ret = get_errno(pause());
2788 break;
2789 #endif
2790 #ifdef TARGET_NR_utime
2791 case TARGET_NR_utime:
2792 {
2793 struct utimbuf tbuf, *host_tbuf;
2794 struct target_utimbuf *target_tbuf;
2795 if (arg2) {
2796 lock_user_struct(target_tbuf, arg2, 1);
2797 tbuf.actime = tswapl(target_tbuf->actime);
2798 tbuf.modtime = tswapl(target_tbuf->modtime);
2799 unlock_user_struct(target_tbuf, arg2, 0);
2800 host_tbuf = &tbuf;
2801 } else {
2802 host_tbuf = NULL;
2803 }
2804 p = lock_user_string(arg1);
2805 ret = get_errno(utime(p, host_tbuf));
2806 unlock_user(p, arg1, 0);
2807 }
2808 break;
2809 #endif
2810 case TARGET_NR_utimes:
2811 {
2812 struct timeval *tvp, tv[2];
2813 if (arg2) {
2814 target_to_host_timeval(&tv[0], arg2);
2815 target_to_host_timeval(&tv[1],
2816 arg2 + sizeof (struct target_timeval));
2817 tvp = tv;
2818 } else {
2819 tvp = NULL;
2820 }
2821 p = lock_user_string(arg1);
2822 ret = get_errno(utimes(p, tvp));
2823 unlock_user(p, arg1, 0);
2824 }
2825 break;
2826 #ifdef TARGET_NR_stty
2827 case TARGET_NR_stty:
2828 goto unimplemented;
2829 #endif
2830 #ifdef TARGET_NR_gtty
2831 case TARGET_NR_gtty:
2832 goto unimplemented;
2833 #endif
2834 case TARGET_NR_access:
2835 p = lock_user_string(arg1);
2836 ret = get_errno(access(p, arg2));
2837 unlock_user(p, arg1, 0);
2838 break;
2839 #ifdef TARGET_NR_nice /* not on alpha */
2840 case TARGET_NR_nice:
2841 ret = get_errno(nice(arg1));
2842 break;
2843 #endif
2844 #ifdef TARGET_NR_ftime
2845 case TARGET_NR_ftime:
2846 goto unimplemented;
2847 #endif
2848 case TARGET_NR_sync:
2849 sync();
2850 ret = 0;
2851 break;
2852 case TARGET_NR_kill:
2853 ret = get_errno(kill(arg1, arg2));
2854 break;
2855 case TARGET_NR_rename:
2856 {
2857 void *p2;
2858 p = lock_user_string(arg1);
2859 p2 = lock_user_string(arg2);
2860 ret = get_errno(rename(p, p2));
2861 unlock_user(p2, arg2, 0);
2862 unlock_user(p, arg1, 0);
2863 }
2864 break;
2865 #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
2866 case TARGET_NR_renameat:
2867 if (!arg2 || !arg4) {
2868 ret = -EFAULT;
2869 goto fail;
2870 }
2871 {
2872 void *p2 = NULL;
2873 p = lock_user_string(arg2);
2874 p2 = lock_user_string(arg4);
2875 if (!access_ok(VERIFY_READ, p, 1)
2876 || !access_ok(VERIFY_READ, p2, 1))
2877 ret = -EFAULT;
2878 else
2879 ret = get_errno(sys_renameat(arg1, p, arg3, p2));
2880 if (p2)
2881 unlock_user(p2, arg4, 0);
2882 if (p)
2883 unlock_user(p, arg2, 0);
2884 }
2885 break;
2886 #endif
2887 case TARGET_NR_mkdir:
2888 p = lock_user_string(arg1);
2889 ret = get_errno(mkdir(p, arg2));
2890 unlock_user(p, arg1, 0);
2891 break;
2892 #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
2893 case TARGET_NR_mkdirat:
2894 if (!arg2) {
2895 ret = -EFAULT;
2896 goto fail;
2897 }
2898 p = lock_user_string(arg2);
2899 if (!access_ok(VERIFY_READ, p, 1))
2900 ret = -EFAULT;
2901 else
2902 ret = get_errno(sys_mkdirat(arg1, p, arg3));
2903 if (p)
2904 unlock_user(p, arg2, 0);
2905 break;
2906 #endif
2907 case TARGET_NR_rmdir:
2908 p = lock_user_string(arg1);
2909 ret = get_errno(rmdir(p));
2910 unlock_user(p, arg1, 0);
2911 break;
2912 case TARGET_NR_dup:
2913 ret = get_errno(dup(arg1));
2914 break;
2915 case TARGET_NR_pipe:
2916 {
2917 int host_pipe[2];
2918 ret = get_errno(pipe(host_pipe));
2919 if (!is_error(ret)) {
2920 #if defined(TARGET_MIPS)
2921 CPUMIPSState *env = (CPUMIPSState*)cpu_env;
2922 env->gpr[3][env->current_tc] = host_pipe[1];
2923 ret = host_pipe[0];
2924 #else
2925 tput32(arg1, host_pipe[0]);
2926 tput32(arg1 + 4, host_pipe[1]);
2927 #endif
2928 }
2929 }
2930 break;
2931 case TARGET_NR_times:
2932 {
2933 struct target_tms *tmsp;
2934 struct tms tms;
2935 ret = get_errno(times(&tms));
2936 if (arg1) {
2937 tmsp = lock_user(arg1, sizeof(struct target_tms), 0);
2938 tmsp->tms_utime = tswapl(host_to_target_clock_t(tms.tms_utime));
2939 tmsp->tms_stime = tswapl(host_to_target_clock_t(tms.tms_stime));
2940 tmsp->tms_cutime = tswapl(host_to_target_clock_t(tms.tms_cutime));
2941 tmsp->tms_cstime = tswapl(host_to_target_clock_t(tms.tms_cstime));
2942 }
2943 if (!is_error(ret))
2944 ret = host_to_target_clock_t(ret);
2945 }
2946 break;
2947 #ifdef TARGET_NR_prof
2948 case TARGET_NR_prof:
2949 goto unimplemented;
2950 #endif
2951 #ifdef TARGET_NR_signal
2952 case TARGET_NR_signal:
2953 goto unimplemented;
2954 #endif
2955 case TARGET_NR_acct:
2956 p = lock_user_string(arg1);
2957 ret = get_errno(acct(path(p)));
2958 unlock_user(p, arg1, 0);
2959 break;
2960 #ifdef TARGET_NR_umount2 /* not on alpha */
2961 case TARGET_NR_umount2:
2962 p = lock_user_string(arg1);
2963 ret = get_errno(umount2(p, arg2));
2964 unlock_user(p, arg1, 0);
2965 break;
2966 #endif
2967 #ifdef TARGET_NR_lock
2968 case TARGET_NR_lock:
2969 goto unimplemented;
2970 #endif
2971 case TARGET_NR_ioctl:
2972 ret = do_ioctl(arg1, arg2, arg3);
2973 break;
2974 case TARGET_NR_fcntl:
2975 ret = get_errno(do_fcntl(arg1, arg2, arg3));
2976 break;
2977 #ifdef TARGET_NR_mpx
2978 case TARGET_NR_mpx:
2979 goto unimplemented;
2980 #endif
2981 case TARGET_NR_setpgid:
2982 ret = get_errno(setpgid(arg1, arg2));
2983 break;
2984 #ifdef TARGET_NR_ulimit
2985 case TARGET_NR_ulimit:
2986 goto unimplemented;
2987 #endif
2988 #ifdef TARGET_NR_oldolduname
2989 case TARGET_NR_oldolduname:
2990 goto unimplemented;
2991 #endif
2992 case TARGET_NR_umask:
2993 ret = get_errno(umask(arg1));
2994 break;
2995 case TARGET_NR_chroot:
2996 p = lock_user_string(arg1);
2997 ret = get_errno(chroot(p));
2998 unlock_user(p, arg1, 0);
2999 break;
3000 case TARGET_NR_ustat:
3001 goto unimplemented;
3002 case TARGET_NR_dup2:
3003 ret = get_errno(dup2(arg1, arg2));
3004 break;
3005 #ifdef TARGET_NR_getppid /* not on alpha */
3006 case TARGET_NR_getppid:
3007 ret = get_errno(getppid());
3008 break;
3009 #endif
3010 case TARGET_NR_getpgrp:
3011 ret = get_errno(getpgrp());
3012 break;
3013 case TARGET_NR_setsid:
3014 ret = get_errno(setsid());
3015 break;
3016 #ifdef TARGET_NR_sigaction
3017 case TARGET_NR_sigaction:
3018 {
3019 #if !defined(TARGET_MIPS)
3020 struct target_old_sigaction *old_act;
3021 struct target_sigaction act, oact, *pact;
3022 if (arg2) {
3023 lock_user_struct(old_act, arg2, 1);
3024 act._sa_handler = old_act->_sa_handler;
3025 target_siginitset(&act.sa_mask, old_act->sa_mask);
3026 act.sa_flags = old_act->sa_flags;
3027 act.sa_restorer = old_act->sa_restorer;
3028 unlock_user_struct(old_act, arg2, 0);
3029 pact = &act;
3030 } else {
3031 pact = NULL;
3032 }
3033 ret = get_errno(do_sigaction(arg1, pact, &oact));
3034 if (!is_error(ret) && arg3) {
3035 lock_user_struct(old_act, arg3, 0);
3036 old_act->_sa_handler = oact._sa_handler;
3037 old_act->sa_mask = oact.sa_mask.sig[0];
3038 old_act->sa_flags = oact.sa_flags;
3039 old_act->sa_restorer = oact.sa_restorer;
3040 unlock_user_struct(old_act, arg3, 1);
3041 }
3042 #else
3043 struct target_sigaction act, oact, *pact, *old_act;
3044
3045 if (arg2) {
3046 lock_user_struct(old_act, arg2, 1);
3047 act._sa_handler = old_act->_sa_handler;
3048 target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);
3049 act.sa_flags = old_act->sa_flags;
3050 unlock_user_struct(old_act, arg2, 0);
3051 pact = &act;
3052 } else {
3053 pact = NULL;
3054 }
3055
3056 ret = get_errno(do_sigaction(arg1, pact, &oact));
3057
3058 if (!is_error(ret) && arg3) {
3059 lock_user_struct(old_act, arg3, 0);
3060 old_act->_sa_handler = oact._sa_handler;
3061 old_act->sa_flags = oact.sa_flags;
3062 old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];
3063 old_act->sa_mask.sig[1] = 0;
3064 old_act->sa_mask.sig[2] = 0;
3065 old_act->sa_mask.sig[3] = 0;
3066 unlock_user_struct(old_act, arg3, 1);
3067 }
3068 #endif
3069 }
3070 break;
3071 #endif
3072 case TARGET_NR_rt_sigaction:
3073 {
3074 struct target_sigaction *act;
3075 struct target_sigaction *oact;
3076
3077 if (arg2)
3078 lock_user_struct(act, arg2, 1);
3079 else
3080 act = NULL;
3081 if (arg3)
3082 lock_user_struct(oact, arg3, 0);
3083 else
3084 oact = NULL;
3085 ret = get_errno(do_sigaction(arg1, act, oact));
3086 if (arg2)
3087 unlock_user_struct(act, arg2, 0);
3088 if (arg3)
3089 unlock_user_struct(oact, arg3, 1);
3090 }
3091 break;
3092 #ifdef TARGET_NR_sgetmask /* not on alpha */
3093 case TARGET_NR_sgetmask:
3094 {
3095 sigset_t cur_set;
3096 target_ulong target_set;
3097 sigprocmask(0, NULL, &cur_set);
3098 host_to_target_old_sigset(&target_set, &cur_set);
3099 ret = target_set;
3100 }
3101 break;
3102 #endif
3103 #ifdef TARGET_NR_ssetmask /* not on alpha */
3104 case TARGET_NR_ssetmask:
3105 {
3106 sigset_t set, oset, cur_set;
3107 target_ulong target_set = arg1;
3108 sigprocmask(0, NULL, &cur_set);
3109 target_to_host_old_sigset(&set, &target_set);
3110 sigorset(&set, &set, &cur_set);
3111 sigprocmask(SIG_SETMASK, &set, &oset);
3112 host_to_target_old_sigset(&target_set, &oset);
3113 ret = target_set;
3114 }
3115 break;
3116 #endif
3117 #ifdef TARGET_NR_sigprocmask
3118 case TARGET_NR_sigprocmask:
3119 {
3120 int how = arg1;
3121 sigset_t set, oldset, *set_ptr;
3122
3123 if (arg2) {
3124 switch(how) {
3125 case TARGET_SIG_BLOCK:
3126 how = SIG_BLOCK;
3127 break;
3128 case TARGET_SIG_UNBLOCK:
3129 how = SIG_UNBLOCK;
3130 break;
3131 case TARGET_SIG_SETMASK:
3132 how = SIG_SETMASK;
3133 break;
3134 default:
3135 ret = -EINVAL;
3136 goto fail;
3137 }
3138 p = lock_user(arg2, sizeof(target_sigset_t), 1);
3139 target_to_host_old_sigset(&set, p);
3140 unlock_user(p, arg2, 0);
3141 set_ptr = &set;
3142 } else {
3143 how = 0;
3144 set_ptr = NULL;
3145 }
3146 ret = get_errno(sigprocmask(arg1, set_ptr, &oldset));
3147 if (!is_error(ret) && arg3) {
3148 p = lock_user(arg3, sizeof(target_sigset_t), 0);
3149 host_to_target_old_sigset(p, &oldset);
3150 unlock_user(p, arg3, sizeof(target_sigset_t));
3151 }
3152 }
3153 break;
3154 #endif
3155 case TARGET_NR_rt_sigprocmask:
3156 {
3157 int how = arg1;
3158 sigset_t set, oldset, *set_ptr;
3159
3160 if (arg2) {
3161 switch(how) {
3162 case TARGET_SIG_BLOCK:
3163 how = SIG_BLOCK;
3164 break;
3165 case TARGET_SIG_UNBLOCK:
3166 how = SIG_UNBLOCK;
3167 break;
3168 case TARGET_SIG_SETMASK:
3169 how = SIG_SETMASK;
3170 break;
3171 default:
3172 ret = -EINVAL;
3173 goto fail;
3174 }
3175 p = lock_user(arg2, sizeof(target_sigset_t), 1);
3176 target_to_host_sigset(&set, p);
3177 unlock_user(p, arg2, 0);
3178 set_ptr = &set;
3179 } else {
3180 how = 0;
3181 set_ptr = NULL;
3182 }
3183 ret = get_errno(sigprocmask(how, set_ptr, &oldset));
3184 if (!is_error(ret) && arg3) {
3185 p = lock_user(arg3, sizeof(target_sigset_t), 0);
3186 host_to_target_sigset(p, &oldset);
3187 unlock_user(p, arg3, sizeof(target_sigset_t));
3188 }
3189 }
3190 break;
3191 #ifdef TARGET_NR_sigpending
3192 case TARGET_NR_sigpending:
3193 {
3194 sigset_t set;
3195 ret = get_errno(sigpending(&set));
3196 if (!is_error(ret)) {
3197 p = lock_user(arg1, sizeof(target_sigset_t), 0);
3198 host_to_target_old_sigset(p, &set);
3199 unlock_user(p, arg1, sizeof(target_sigset_t));
3200 }
3201 }
3202 break;
3203 #endif
3204 case TARGET_NR_rt_sigpending:
3205 {
3206 sigset_t set;
3207 ret = get_errno(sigpending(&set));
3208 if (!is_error(ret)) {
3209 p = lock_user(arg1, sizeof(target_sigset_t), 0);
3210 host_to_target_sigset(p, &set);
3211 unlock_user(p, arg1, sizeof(target_sigset_t));
3212 }
3213 }
3214 break;
3215 #ifdef TARGET_NR_sigsuspend
3216 case TARGET_NR_sigsuspend:
3217 {
3218 sigset_t set;
3219 p = lock_user(arg1, sizeof(target_sigset_t), 1);
3220 target_to_host_old_sigset(&set, p);
3221 unlock_user(p, arg1, 0);
3222 ret = get_errno(sigsuspend(&set));
3223 }
3224 break;
3225 #endif
3226 case TARGET_NR_rt_sigsuspend:
3227 {
3228 sigset_t set;
3229 p = lock_user(arg1, sizeof(target_sigset_t), 1);
3230 target_to_host_sigset(&set, p);
3231 unlock_user(p, arg1, 0);
3232 ret = get_errno(sigsuspend(&set));
3233 }
3234 break;
3235 case TARGET_NR_rt_sigtimedwait:
3236 {
3237 sigset_t set;
3238 struct timespec uts, *puts;
3239 siginfo_t uinfo;
3240
3241 p = lock_user(arg1, sizeof(target_sigset_t), 1);
3242 target_to_host_sigset(&set, p);
3243 unlock_user(p, arg1, 0);
3244 if (arg3) {
3245 puts = &uts;
3246 target_to_host_timespec(puts, arg3);
3247 } else {
3248 puts = NULL;
3249 }
3250 ret = get_errno(sigtimedwait(&set, &uinfo, puts));
3251 if (!is_error(ret) && arg2) {
3252 p = lock_user(arg2, sizeof(target_sigset_t), 0);
3253 host_to_target_siginfo(p, &uinfo);
3254 unlock_user(p, arg2, sizeof(target_sigset_t));
3255 }
3256 }
3257 break;
3258 case TARGET_NR_rt_sigqueueinfo:
3259 {
3260 siginfo_t uinfo;
3261 p = lock_user(arg3, sizeof(target_sigset_t), 1);
3262 target_to_host_siginfo(&uinfo, p);
3263 unlock_user(p, arg1, 0);
3264 ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));
3265 }
3266 break;
3267 #ifdef TARGET_NR_sigreturn
3268 case TARGET_NR_sigreturn:
3269 /* NOTE: ret is eax, so not transcoding must be done */
3270 ret = do_sigreturn(cpu_env);
3271 break;
3272 #endif
3273 case TARGET_NR_rt_sigreturn:
3274 /* NOTE: ret is eax, so not transcoding must be done */
3275 ret = do_rt_sigreturn(cpu_env);
3276 break;
3277 case TARGET_NR_sethostname:
3278 p = lock_user_string(arg1);
3279 ret = get_errno(sethostname(p, arg2));
3280 unlock_user(p, arg1, 0);
3281 break;
3282 case TARGET_NR_setrlimit:
3283 {
3284 /* XXX: convert resource ? */
3285 int resource = arg1;
3286 struct target_rlimit *target_rlim;
3287 struct rlimit rlim;
3288 lock_user_struct(target_rlim, arg2, 1);
3289 rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
3290 rlim.rlim_max = tswapl(target_rlim->rlim_max);
3291 unlock_user_struct(target_rlim, arg2, 0);
3292 ret = get_errno(setrlimit(resource, &rlim));
3293 }
3294 break;
3295 case TARGET_NR_getrlimit:
3296 {
3297 /* XXX: convert resource ? */
3298 int resource = arg1;
3299 struct target_rlimit *target_rlim;
3300 struct rlimit rlim;
3301
3302 ret = get_errno(getrlimit(resource, &rlim));
3303 if (!is_error(ret)) {
3304 lock_user_struct(target_rlim, arg2, 0);
3305 rlim.rlim_cur = tswapl(target_rlim->rlim_cur);
3306 rlim.rlim_max = tswapl(target_rlim->rlim_max);
3307 unlock_user_struct(target_rlim, arg2, 1);
3308 }
3309 }
3310 break;
3311 case TARGET_NR_getrusage:
3312 {
3313 struct rusage rusage;
3314 ret = get_errno(getrusage(arg1, &rusage));
3315 if (!is_error(ret)) {
3316 host_to_target_rusage(arg2, &rusage);
3317 }
3318 }
3319 break;
3320 case TARGET_NR_gettimeofday:
3321 {
3322 struct timeval tv;
3323 ret = get_errno(gettimeofday(&tv, NULL));
3324 if (!is_error(ret)) {
3325 host_to_target_timeval(arg1, &tv);
3326 }
3327 }
3328 break;
3329 case TARGET_NR_settimeofday:
3330 {
3331 struct timeval tv;
3332 target_to_host_timeval(&tv, arg1);
3333 ret = get_errno(settimeofday(&tv, NULL));
3334 }
3335 break;
3336 #ifdef TARGET_NR_select
3337 case TARGET_NR_select:
3338 {
3339 struct target_sel_arg_struct *sel;
3340 target_ulong inp, outp, exp, tvp;
3341 long nsel;
3342
3343 lock_user_struct(sel, arg1, 1);
3344 nsel = tswapl(sel->n);
3345 inp = tswapl(sel->inp);
3346 outp = tswapl(sel->outp);
3347 exp = tswapl(sel->exp);
3348 tvp = tswapl(sel->tvp);
3349 unlock_user_struct(sel, arg1, 0);
3350 ret = do_select(nsel, inp, outp, exp, tvp);
3351 }
3352 break;
3353 #endif
3354 case TARGET_NR_symlink:
3355 {
3356 void *p2;
3357 p = lock_user_string(arg1);
3358 p2 = lock_user_string(arg2);
3359 ret = get_errno(symlink(p, p2));
3360 unlock_user(p2, arg2, 0);
3361 unlock_user(p, arg1, 0);
3362 }
3363 break;
3364 #ifdef TARGET_NR_oldlstat
3365 case TARGET_NR_oldlstat:
3366 goto unimplemented;
3367 #endif
3368 case TARGET_NR_readlink:
3369 {
3370 void *p2;
3371 p = lock_user_string(arg1);
3372 p2 = lock_user(arg2, arg3, 0);
3373 ret = get_errno(readlink(path(p), p2, arg3));
3374 unlock_user(p2, arg2, ret);
3375 unlock_user(p, arg1, 0);
3376 }
3377 break;
3378 #ifdef TARGET_NR_uselib
3379 case TARGET_NR_uselib:
3380 goto unimplemented;
3381 #endif
3382 #ifdef TARGET_NR_swapon
3383 case TARGET_NR_swapon:
3384 p = lock_user_string(arg1);
3385 ret = get_errno(swapon(p, arg2));
3386 unlock_user(p, arg1, 0);
3387 break;
3388 #endif
3389 case TARGET_NR_reboot:
3390 goto unimplemented;
3391 #ifdef TARGET_NR_readdir
3392 case TARGET_NR_readdir:
3393 goto unimplemented;
3394 #endif
3395 #ifdef TARGET_NR_mmap
3396 case TARGET_NR_mmap:
3397 #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_M68K)
3398 {
3399 target_ulong *v;
3400 target_ulong v1, v2, v3, v4, v5, v6;
3401 v = lock_user(arg1, 6 * sizeof(target_ulong), 1);
3402 v1 = tswapl(v[0]);
3403 v2 = tswapl(v[1]);
3404 v3 = tswapl(v[2]);
3405 v4 = tswapl(v[3]);
3406 v5 = tswapl(v[4]);
3407 v6 = tswapl(v[5]);
3408 unlock_user(v, arg1, 0);
3409 ret = get_errno(target_mmap(v1, v2, v3,
3410 target_to_host_bitmask(v4, mmap_flags_tbl),
3411 v5, v6));
3412 }
3413 #else
3414 ret = get_errno(target_mmap(arg1, arg2, arg3,
3415 target_to_host_bitmask(arg4, mmap_flags_tbl),
3416 arg5,
3417 arg6));
3418 #endif
3419 break;
3420 #endif
3421 #ifdef TARGET_NR_mmap2
3422 case TARGET_NR_mmap2:
3423 #if defined(TARGET_SPARC) || defined(TARGET_MIPS)
3424 #define MMAP_SHIFT 12
3425 #else
3426 #define MMAP_SHIFT TARGET_PAGE_BITS
3427 #endif
3428 ret = get_errno(target_mmap(arg1, arg2, arg3,
3429 target_to_host_bitmask(arg4, mmap_flags_tbl),
3430 arg5,
3431 arg6 << MMAP_SHIFT));
3432 break;
3433 #endif
3434 case TARGET_NR_munmap:
3435 ret = get_errno(target_munmap(arg1, arg2));
3436 break;
3437 case TARGET_NR_mprotect:
3438 ret = get_errno(target_mprotect(arg1, arg2, arg3));
3439 break;
3440 #ifdef TARGET_NR_mremap
3441 case TARGET_NR_mremap:
3442 ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));
3443 break;
3444 #endif
3445 /* ??? msync/mlock/munlock are broken for softmmu. */
3446 #ifdef TARGET_NR_msync
3447 case TARGET_NR_msync:
3448 ret = get_errno(msync(g2h(arg1), arg2, arg3));
3449 break;
3450 #endif
3451 #ifdef TARGET_NR_mlock
3452 case TARGET_NR_mlock:
3453 ret = get_errno(mlock(g2h(arg1), arg2));
3454 break;
3455 #endif
3456 #ifdef TARGET_NR_munlock
3457 case TARGET_NR_munlock:
3458 ret = get_errno(munlock(g2h(arg1), arg2));
3459 break;
3460 #endif
3461 #ifdef TARGET_NR_mlockall
3462 case TARGET_NR_mlockall:
3463 ret = get_errno(mlockall(arg1));
3464 break;
3465 #endif
3466 #ifdef TARGET_NR_munlockall
3467 case TARGET_NR_munlockall:
3468 ret = get_errno(munlockall());
3469 break;
3470 #endif
3471 case TARGET_NR_truncate:
3472 p = lock_user_string(arg1);
3473 ret = get_errno(truncate(p, arg2));
3474 unlock_user(p, arg1, 0);
3475 break;
3476 case TARGET_NR_ftruncate:
3477 ret = get_errno(ftruncate(arg1, arg2));
3478 break;
3479 case TARGET_NR_fchmod:
3480 ret = get_errno(fchmod(arg1, arg2));
3481 break;
3482 case TARGET_NR_getpriority:
3483 ret = get_errno(getpriority(arg1, arg2));
3484 break;
3485 case TARGET_NR_setpriority:
3486 ret = get_errno(setpriority(arg1, arg2, arg3));
3487 break;
3488 #ifdef TARGET_NR_profil
3489 case TARGET_NR_profil:
3490 goto unimplemented;
3491 #endif
3492 case TARGET_NR_statfs:
3493 p = lock_user_string(arg1);
3494 ret = get_errno(statfs(path(p), &stfs));
3495 unlock_user(p, arg1, 0);
3496 convert_statfs:
3497 if (!is_error(ret)) {
3498 struct target_statfs *target_stfs;
3499
3500 lock_user_struct(target_stfs, arg2, 0);
3501 /* ??? put_user is probably wrong. */
3502 put_user(stfs.f_type, &target_stfs->f_type);
3503 put_user(stfs.f_bsize, &target_stfs->f_bsize);
3504 put_user(stfs.f_blocks, &target_stfs->f_blocks);
3505 put_user(stfs.f_bfree, &target_stfs->f_bfree);
3506 put_user(stfs.f_bavail, &target_stfs->f_bavail);
3507 put_user(stfs.f_files, &target_stfs->f_files);
3508 put_user(stfs.f_ffree, &target_stfs->f_ffree);
3509 put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
3510 put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
3511 put_user(stfs.f_namelen, &target_stfs->f_namelen);
3512 unlock_user_struct(target_stfs, arg2, 1);
3513 }
3514 break;
3515 case TARGET_NR_fstatfs:
3516 ret = get_errno(fstatfs(arg1, &stfs));
3517 goto convert_statfs;
3518 #ifdef TARGET_NR_statfs64
3519 case TARGET_NR_statfs64:
3520 p = lock_user_string(arg1);
3521 ret = get_errno(statfs(path(p), &stfs));
3522 unlock_user(p, arg1, 0);
3523 convert_statfs64:
3524 if (!is_error(ret)) {
3525 struct target_statfs64 *target_stfs;
3526
3527 lock_user_struct(target_stfs, arg3, 0);
3528 /* ??? put_user is probably wrong. */
3529 put_user(stfs.f_type, &target_stfs->f_type);
3530 put_user(stfs.f_bsize, &target_stfs->f_bsize);
3531 put_user(stfs.f_blocks, &target_stfs->f_blocks);
3532 put_user(stfs.f_bfree, &target_stfs->f_bfree);
3533 put_user(stfs.f_bavail, &target_stfs->f_bavail);
3534 put_user(stfs.f_files, &target_stfs->f_files);
3535 put_user(stfs.f_ffree, &target_stfs->f_ffree);
3536 put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);
3537 put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);
3538 put_user(stfs.f_namelen, &target_stfs->f_namelen);
3539 unlock_user_struct(target_stfs, arg3, 0);
3540 }
3541 break;
3542 case TARGET_NR_fstatfs64:
3543 ret = get_errno(fstatfs(arg1, &stfs));
3544 goto convert_statfs64;
3545 #endif
3546 #ifdef TARGET_NR_ioperm
3547 case TARGET_NR_ioperm:
3548 goto unimplemented;
3549 #endif
3550 #ifdef TARGET_NR_socketcall
3551 case TARGET_NR_socketcall:
3552 ret = do_socketcall(arg1, arg2);
3553 break;
3554 #endif
3555 #ifdef TARGET_NR_accept
3556 case TARGET_NR_accept:
3557 ret = do_accept(arg1, arg2, arg3);
3558 break;
3559 #endif
3560 #ifdef TARGET_NR_bind
3561 case TARGET_NR_bind:
3562 ret = do_bind(arg1, arg2, arg3);
3563 break;
3564 #endif
3565 #ifdef TARGET_NR_connect
3566 case TARGET_NR_connect:
3567 ret = do_connect(arg1, arg2, arg3);
3568 break;
3569 #endif
3570 #ifdef TARGET_NR_getpeername
3571 case TARGET_NR_getpeername:
3572 ret = do_getpeername(arg1, arg2, arg3);
3573 break;
3574 #endif
3575 #ifdef TARGET_NR_getsockname
3576 case TARGET_NR_getsockname:
3577 ret = do_getsockname(arg1, arg2, arg3);
3578 break;
3579 #endif
3580 #ifdef TARGET_NR_getsockopt
3581 case TARGET_NR_getsockopt:
3582 ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);
3583 break;
3584 #endif
3585 #ifdef TARGET_NR_listen
3586 case TARGET_NR_listen:
3587 ret = get_errno(listen(arg1, arg2));
3588 break;
3589 #endif
3590 #ifdef TARGET_NR_recv
3591 case TARGET_NR_recv:
3592 ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);
3593 break;
3594 #endif
3595 #ifdef TARGET_NR_recvfrom
3596 case TARGET_NR_recvfrom:
3597 ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);
3598 break;
3599 #endif
3600 #ifdef TARGET_NR_recvmsg
3601 case TARGET_NR_recvmsg:
3602 ret = do_sendrecvmsg(arg1, arg2, arg3, 0);
3603 break;
3604 #endif
3605 #ifdef TARGET_NR_send
3606 case TARGET_NR_send:
3607 ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);
3608 break;
3609 #endif
3610 #ifdef TARGET_NR_sendmsg
3611 case TARGET_NR_sendmsg:
3612 ret = do_sendrecvmsg(arg1, arg2, arg3, 1);
3613 break;
3614 #endif
3615 #ifdef TARGET_NR_sendto
3616 case TARGET_NR_sendto:
3617 ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);
3618 break;
3619 #endif
3620 #ifdef TARGET_NR_shutdown
3621 case TARGET_NR_shutdown:
3622 ret = get_errno(shutdown(arg1, arg2));
3623 break;
3624 #endif
3625 #ifdef TARGET_NR_socket
3626 case TARGET_NR_socket:
3627 ret = do_socket(arg1, arg2, arg3);
3628 break;
3629 #endif
3630 #ifdef TARGET_NR_socketpair
3631 case TARGET_NR_socketpair:
3632 ret = do_socketpair(arg1, arg2, arg3, arg4);
3633 break;
3634 #endif
3635 #ifdef TARGET_NR_setsockopt
3636 case TARGET_NR_setsockopt:
3637 ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);
3638 break;
3639 #endif
3640
3641 case TARGET_NR_syslog:
3642 p = lock_user_string(arg2);
3643 ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));
3644 unlock_user(p, arg2, 0);
3645 break;
3646
3647 case TARGET_NR_setitimer:
3648 {
3649 struct itimerval value, ovalue, *pvalue;
3650
3651 if (arg2) {
3652 pvalue = &value;
3653 target_to_host_timeval(&pvalue->it_interval,
3654 arg2);
3655 target_to_host_timeval(&pvalue->it_value,
3656 arg2 + sizeof(struct target_timeval));
3657 } else {
3658 pvalue = NULL;
3659 }
3660 ret = get_errno(setitimer(arg1, pvalue, &ovalue));
3661 if (!is_error(ret) && arg3) {
3662 host_to_target_timeval(arg3,
3663 &ovalue.it_interval);
3664 host_to_target_timeval(arg3 + sizeof(struct target_timeval),
3665 &ovalue.it_value);
3666 }
3667 }
3668 break;
3669 case TARGET_NR_getitimer:
3670 {
3671 struct itimerval value;
3672
3673 ret = get_errno(getitimer(arg1, &value));
3674 if (!is_error(ret) && arg2) {
3675 host_to_target_timeval(arg2,
3676 &value.it_interval);
3677 host_to_target_timeval(arg2 + sizeof(struct target_timeval),
3678 &value.it_value);
3679 }
3680 }
3681 break;
3682 case TARGET_NR_stat:
3683 p = lock_user_string(arg1);
3684 ret = get_errno(stat(path(p), &st));
3685 unlock_user(p, arg1, 0);
3686 goto do_stat;
3687 case TARGET_NR_lstat:
3688 p = lock_user_string(arg1);
3689 ret = get_errno(lstat(path(p), &st));
3690 unlock_user(p, arg1, 0);
3691 goto do_stat;
3692 case TARGET_NR_fstat:
3693 {
3694 ret = get_errno(fstat(arg1, &st));
3695 do_stat:
3696 if (!is_error(ret)) {
3697 struct target_stat *target_st;
3698
3699 lock_user_struct(target_st, arg2, 0);
3700 #if defined(TARGET_MIPS) || defined(TARGET_SPARC64)
3701 target_st->st_dev = tswap32(st.st_dev);
3702 #else
3703 target_st->st_dev = tswap16(st.st_dev);
3704 #endif
3705 target_st->st_ino = tswapl(st.st_ino);
3706 #if defined(TARGET_PPC) || defined(TARGET_MIPS)
3707 target_st->st_mode = tswapl(st.st_mode); /* XXX: check this */
3708 target_st->st_uid = tswap32(st.st_uid);
3709 target_st->st_gid = tswap32(st.st_gid);
3710 #elif defined(TARGET_SPARC64)
3711 target_st->st_mode = tswap32(st.st_mode);
3712 target_st->st_uid = tswap32(st.st_uid);
3713 target_st->st_gid = tswap32(st.st_gid);
3714 #else
3715 target_st->st_mode = tswap16(st.st_mode);
3716 target_st->st_uid = tswap16(st.st_uid);
3717 target_st->st_gid = tswap16(st.st_gid);
3718 #endif
3719 #if defined(TARGET_MIPS)
3720 /* If this is the same on PPC, then just merge w/ the above ifdef */
3721 target_st->st_nlink = tswapl(st.st_nlink);
3722 target_st->st_rdev = tswapl(st.st_rdev);
3723 #elif defined(TARGET_SPARC64)
3724 target_st->st_nlink = tswap32(st.st_nlink);
3725 target_st->st_rdev = tswap32(st.st_rdev);
3726 #else
3727 target_st->st_nlink = tswap16(st.st_nlink);
3728 target_st->st_rdev = tswap16(st.st_rdev);
3729 #endif
3730 target_st->st_size = tswapl(st.st_size);
3731 target_st->st_blksize = tswapl(st.st_blksize);
3732 target_st->st_blocks = tswapl(st.st_blocks);
3733 target_st->target_st_atime = tswapl(st.st_atime);
3734 target_st->target_st_mtime = tswapl(st.st_mtime);
3735 target_st->target_st_ctime = tswapl(st.st_ctime);
3736 unlock_user_struct(target_st, arg2, 1);
3737 }
3738 }
3739 break;
3740 #ifdef TARGET_NR_olduname
3741 case TARGET_NR_olduname:
3742 goto unimplemented;
3743 #endif
3744 #ifdef TARGET_NR_iopl
3745 case TARGET_NR_iopl:
3746 goto unimplemented;
3747 #endif
3748 case TARGET_NR_vhangup:
3749 ret = get_errno(vhangup());
3750 break;
3751 #ifdef TARGET_NR_idle
3752 case TARGET_NR_idle:
3753 goto unimplemented;
3754 #endif
3755 #ifdef TARGET_NR_syscall
3756 case TARGET_NR_syscall:
3757 ret = do_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);
3758 break;
3759 #endif
3760 case TARGET_NR_wait4:
3761 {
3762 int status;
3763 target_long status_ptr = arg2;
3764 struct rusage rusage, *rusage_ptr;
3765 target_ulong target_rusage = arg4;
3766 if (target_rusage)
3767 rusage_ptr = &rusage;
3768 else
3769 rusage_ptr = NULL;
3770 ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr));
3771 if (!is_error(ret)) {
3772 if (status_ptr)
3773 tputl(status_ptr, status);
3774 if (target_rusage) {
3775 host_to_target_rusage(target_rusage, &rusage);
3776 }
3777 }
3778 }
3779 break;
3780 #ifdef TARGET_NR_swapoff
3781 case TARGET_NR_swapoff:
3782 p = lock_user_string(arg1);
3783 ret = get_errno(swapoff(p));
3784 unlock_user(p, arg1, 0);
3785 break;
3786 #endif
3787 case TARGET_NR_sysinfo:
3788 {
3789 struct target_sysinfo *target_value;
3790 struct sysinfo value;
3791 ret = get_errno(sysinfo(&value));
3792 if (!is_error(ret) && arg1)
3793 {
3794 /* ??? __put_user is probably wrong. */
3795 lock_user_struct(target_value, arg1, 0);
3796 __put_user(value.uptime, &target_value->uptime);
3797 __put_user(value.loads[0], &target_value->loads[0]);
3798 __put_user(value.loads[1], &target_value->loads[1]);
3799 __put_user(value.loads[2], &target_value->loads[2]);
3800 __put_user(value.totalram, &target_value->totalram);
3801 __put_user(value.freeram, &target_value->freeram);
3802 __put_user(value.sharedram, &target_value->sharedram);
3803 __put_user(value.bufferram, &target_value->bufferram);
3804 __put_user(value.totalswap, &target_value->totalswap);
3805 __put_user(value.freeswap, &target_value->freeswap);
3806 __put_user(value.procs, &target_value->procs);
3807 __put_user(value.totalhigh, &target_value->totalhigh);
3808 __put_user(value.freehigh, &target_value->freehigh);
3809 __put_user(value.mem_unit, &target_value->mem_unit);
3810 unlock_user_struct(target_value, arg1, 1);
3811 }
3812 }
3813 break;
3814 #ifdef TARGET_NR_ipc
3815 case TARGET_NR_ipc:
3816 ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);
3817 break;
3818 #endif
3819 case TARGET_NR_fsync:
3820 ret = get_errno(fsync(arg1));
3821 break;
3822 case TARGET_NR_clone:
3823 ret = get_errno(do_fork(cpu_env, arg1, arg2));
3824 break;
3825 #ifdef __NR_exit_group
3826 /* new thread calls */
3827 case TARGET_NR_exit_group:
3828 gdb_exit(cpu_env, arg1);
3829 ret = get_errno(exit_group(arg1));
3830 break;
3831 #endif
3832 case TARGET_NR_setdomainname:
3833 p = lock_user_string(arg1);
3834 ret = get_errno(setdomainname(p, arg2));
3835 unlock_user(p, arg1, 0);
3836 break;
3837 case TARGET_NR_uname:
3838 /* no need to transcode because we use the linux syscall */
3839 {
3840 struct new_utsname * buf;
3841
3842 lock_user_struct(buf, arg1, 0);
3843 ret = get_errno(sys_uname(buf));
3844 if (!is_error(ret)) {
3845 /* Overrite the native machine name with whatever is being
3846 emulated. */
3847 strcpy (buf->machine, UNAME_MACHINE);
3848 /* Allow the user to override the reported release. */
3849 if (qemu_uname_release && *qemu_uname_release)
3850 strcpy (buf->release, qemu_uname_release);
3851 }
3852 unlock_user_struct(buf, arg1, 1);
3853 }
3854 break;
3855 #ifdef TARGET_I386
3856 case TARGET_NR_modify_ldt:
3857 ret = get_errno(do_modify_ldt(cpu_env, arg1, arg2, arg3));
3858 break;
3859 #if !defined(TARGET_X86_64)
3860 case TARGET_NR_vm86old:
3861 goto unimplemented;
3862 case TARGET_NR_vm86:
3863 ret = do_vm86(cpu_env, arg1, arg2);
3864 break;
3865 #endif
3866 #endif
3867 case TARGET_NR_adjtimex:
3868 goto unimplemented;
3869 #ifdef TARGET_NR_create_module
3870 case TARGET_NR_create_module:
3871 #endif
3872 case TARGET_NR_init_module:
3873 case TARGET_NR_delete_module:
3874 #ifdef TARGET_NR_get_kernel_syms
3875 case TARGET_NR_get_kernel_syms:
3876 #endif
3877 goto unimplemented;
3878 case TARGET_NR_quotactl:
3879 goto unimplemented;
3880 case TARGET_NR_getpgid:
3881 ret = get_errno(getpgid(arg1));
3882 break;
3883 case TARGET_NR_fchdir:
3884 ret = get_errno(fchdir(arg1));
3885 break;
3886 #ifdef TARGET_NR_bdflush /* not on x86_64 */
3887 case TARGET_NR_bdflush:
3888 goto unimplemented;
3889 #endif
3890 #ifdef TARGET_NR_sysfs
3891 case TARGET_NR_sysfs:
3892 goto unimplemented;
3893 #endif
3894 case TARGET_NR_personality:
3895 ret = get_errno(personality(arg1));
3896 break;
3897 #ifdef TARGET_NR_afs_syscall
3898 case TARGET_NR_afs_syscall:
3899 goto unimplemented;
3900 #endif
3901 #ifdef TARGET_NR__llseek /* Not on alpha */
3902 case TARGET_NR__llseek:
3903 {
3904 #if defined (__x86_64__)
3905 ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5));
3906 tput64(arg4, ret);
3907 #else
3908 int64_t res;
3909 ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));
3910 tput64(arg4, res);
3911 #endif
3912 }
3913 break;
3914 #endif
3915 case TARGET_NR_getdents:
3916 #if TARGET_LONG_SIZE != 4
3917 goto unimplemented;
3918 #warning not supported
3919 #elif TARGET_LONG_SIZE == 4 && HOST_LONG_SIZE == 8
3920 {
3921 struct target_dirent *target_dirp;
3922 struct dirent *dirp;
3923 long count = arg3;
3924
3925 dirp = malloc(count);
3926 if (!dirp)
3927 return -ENOMEM;
3928
3929 ret = get_errno(sys_getdents(arg1, dirp, count));
3930 if (!is_error(ret)) {
3931 struct dirent *de;
3932 struct target_dirent *tde;
3933 int len = ret;
3934 int reclen, treclen;
3935 int count1, tnamelen;
3936
3937 count1 = 0;
3938 de = dirp;
3939 target_dirp = lock_user(arg2, count, 0);
3940 tde = target_dirp;
3941 while (len > 0) {
3942 reclen = de->d_reclen;
3943 treclen = reclen - (2 * (sizeof(long) - sizeof(target_long)));
3944 tde->d_reclen = tswap16(treclen);
3945 tde->d_ino = tswapl(de->d_ino);
3946 tde->d_off = tswapl(de->d_off);
3947 tnamelen = treclen - (2 * sizeof(target_long) + 2);
3948 if (tnamelen > 256)
3949 tnamelen = 256;
3950 /* XXX: may not be correct */
3951 strncpy(tde->d_name, de->d_name, tnamelen);
3952 de = (struct dirent *)((char *)de + reclen);
3953 len -= reclen;
3954 tde = (struct target_dirent *)((char *)tde + treclen);
3955 count1 += treclen;
3956 }
3957 ret = count1;
3958 }
3959 unlock_user(target_dirp, arg2, ret);
3960 free(dirp);
3961 }
3962 #else
3963 {
3964 struct dirent *dirp;
3965 long count = arg3;
3966
3967 dirp = lock_user(arg2, count, 0);
3968 ret = get_errno(sys_getdents(arg1, dirp, count));
3969 if (!is_error(ret)) {
3970 struct dirent *de;
3971 int len = ret;
3972 int reclen;
3973 de = dirp;
3974 while (len > 0) {
3975 reclen = de->d_reclen;
3976 if (reclen > len)
3977 break;
3978 de->d_reclen = tswap16(reclen);
3979 tswapls(&de->d_ino);
3980 tswapls(&de->d_off);
3981 de = (struct dirent *)((char *)de + reclen);
3982 len -= reclen;
3983 }
3984 }
3985 unlock_user(dirp, arg2, ret);
3986 }
3987 #endif
3988 break;
3989 #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
3990 case TARGET_NR_getdents64:
3991 {
3992 struct dirent64 *dirp;
3993 long count = arg3;
3994 dirp = lock_user(arg2, count, 0);
3995 ret = get_errno(sys_getdents64(arg1, dirp, count));
3996 if (!is_error(ret)) {
3997 struct dirent64 *de;
3998 int len = ret;
3999 int reclen;
4000 de = dirp;
4001 while (len > 0) {
4002 reclen = de->d_reclen;
4003 if (reclen > len)
4004 break;
4005 de->d_reclen = tswap16(reclen);
4006 tswap64s(&de->d_ino);
4007 tswap64s(&de->d_off);
4008 de = (struct dirent64 *)((char *)de + reclen);
4009 len -= reclen;
4010 }
4011 }
4012 unlock_user(dirp, arg2, ret);
4013 }
4014 break;
4015 #endif /* TARGET_NR_getdents64 */
4016 #ifdef TARGET_NR__newselect
4017 case TARGET_NR__newselect:
4018 ret = do_select(arg1, arg2, arg3, arg4, arg5);
4019 break;
4020 #endif
4021 #ifdef TARGET_NR_poll
4022 case TARGET_NR_poll:
4023 {
4024 struct target_pollfd *target_pfd;
4025 unsigned int nfds = arg2;
4026 int timeout = arg3;
4027 struct pollfd *pfd;
4028 unsigned int i;
4029
4030 target_pfd = lock_user(arg1, sizeof(struct target_pollfd) * nfds, 1);
4031 pfd = alloca(sizeof(struct pollfd) * nfds);
4032 for(i = 0; i < nfds; i++) {
4033 pfd[i].fd = tswap32(target_pfd[i].fd);
4034 pfd[i].events = tswap16(target_pfd[i].events);
4035 }
4036 ret = get_errno(poll(pfd, nfds, timeout));
4037 if (!is_error(ret)) {
4038 for(i = 0; i < nfds; i++) {
4039 target_pfd[i].revents = tswap16(pfd[i].revents);
4040 }
4041 ret += nfds * (sizeof(struct target_pollfd)
4042 - sizeof(struct pollfd));
4043 }
4044 unlock_user(target_pfd, arg1, ret);
4045 }
4046 break;
4047 #endif
4048 case TARGET_NR_flock:
4049 /* NOTE: the flock constant seems to be the same for every
4050 Linux platform */
4051 ret = get_errno(flock(arg1, arg2));
4052 break;
4053 case TARGET_NR_readv:
4054 {
4055 int count = arg3;
4056 struct iovec *vec;
4057
4058 vec = alloca(count * sizeof(struct iovec));
4059 lock_iovec(vec, arg2, count, 0);
4060 ret = get_errno(readv(arg1, vec, count));
4061 unlock_iovec(vec, arg2, count, 1);
4062 }
4063 break;
4064 case TARGET_NR_writev:
4065 {
4066 int count = arg3;
4067 struct iovec *vec;
4068
4069 vec = alloca(count * sizeof(struct iovec));
4070 lock_iovec(vec, arg2, count, 1);
4071 ret = get_errno(writev(arg1, vec, count));
4072 unlock_iovec(vec, arg2, count, 0);
4073 }
4074 break;
4075 case TARGET_NR_getsid:
4076 ret = get_errno(getsid(arg1));
4077 break;
4078 #if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */
4079 case TARGET_NR_fdatasync:
4080 ret = get_errno(fdatasync(arg1));
4081 break;
4082 #endif
4083 case TARGET_NR__sysctl:
4084 /* We don't implement this, but ENODIR is always a safe
4085 return value. */
4086 return -ENOTDIR;
4087 case TARGET_NR_sched_setparam:
4088 {
4089 struct sched_param *target_schp;
4090 struct sched_param schp;
4091
4092 lock_user_struct(target_schp, arg2, 1);
4093 schp.sched_priority = tswap32(target_schp->sched_priority);
4094 unlock_user_struct(target_schp, arg2, 0);
4095 ret = get_errno(sched_setparam(arg1, &schp));
4096 }
4097 break;
4098 case TARGET_NR_sched_getparam:
4099 {
4100 struct sched_param *target_schp;
4101 struct sched_param schp;
4102 ret = get_errno(sched_getparam(arg1, &schp));
4103 if (!is_error(ret)) {
4104 lock_user_struct(target_schp, arg2, 0);
4105 target_schp->sched_priority = tswap32(schp.sched_priority);
4106 unlock_user_struct(target_schp, arg2, 1);
4107 }
4108 }
4109 break;
4110 case TARGET_NR_sched_setscheduler:
4111 {
4112 struct sched_param *target_schp;
4113 struct sched_param schp;
4114 lock_user_struct(target_schp, arg3, 1);
4115 schp.sched_priority = tswap32(target_schp->sched_priority);
4116 unlock_user_struct(target_schp, arg3, 0);
4117 ret = get_errno(sched_setscheduler(arg1, arg2, &schp));
4118 }
4119 break;
4120 case TARGET_NR_sched_getscheduler:
4121 ret = get_errno(sched_getscheduler(arg1));
4122 break;
4123 case TARGET_NR_sched_yield:
4124 ret = get_errno(sched_yield());
4125 break;
4126 case TARGET_NR_sched_get_priority_max:
4127 ret = get_errno(sched_get_priority_max(arg1));
4128 break;
4129 case TARGET_NR_sched_get_priority_min:
4130 ret = get_errno(sched_get_priority_min(arg1));
4131 break;
4132 case TARGET_NR_sched_rr_get_interval:
4133 {
4134 struct timespec ts;
4135 ret = get_errno(sched_rr_get_interval(arg1, &ts));
4136 if (!is_error(ret)) {
4137 host_to_target_timespec(arg2, &ts);
4138 }
4139 }
4140 break;
4141 case TARGET_NR_nanosleep:
4142 {
4143 struct timespec req, rem;
4144 target_to_host_timespec(&req, arg1);
4145 ret = get_errno(nanosleep(&req, &rem));
4146 if (is_error(ret) && arg2) {
4147 host_to_target_timespec(arg2, &rem);
4148 }
4149 }
4150 break;
4151 #ifdef TARGET_NR_query_module
4152 case TARGET_NR_query_module:
4153 goto unimplemented;
4154 #endif
4155 #ifdef TARGET_NR_nfsservctl
4156 case TARGET_NR_nfsservctl:
4157 goto unimplemented;
4158 #endif
4159 case TARGET_NR_prctl:
4160 switch (arg1)
4161 {
4162 case PR_GET_PDEATHSIG:
4163 {
4164 int deathsig;
4165 ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));
4166 if (!is_error(ret) && arg2)
4167 tput32(arg2, deathsig);
4168 }
4169 break;
4170 default:
4171 ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));
4172 break;
4173 }
4174 break;
4175 #ifdef TARGET_NR_pread
4176 case TARGET_NR_pread:
4177 page_unprotect_range(arg2, arg3);
4178 p = lock_user(arg2, arg3, 0);
4179 ret = get_errno(pread(arg1, p, arg3, arg4));
4180 unlock_user(p, arg2, ret);
4181 break;
4182 case TARGET_NR_pwrite:
4183 p = lock_user(arg2, arg3, 1);
4184 ret = get_errno(pwrite(arg1, p, arg3, arg4));
4185 unlock_user(p, arg2, 0);
4186 break;
4187 #endif
4188 case TARGET_NR_getcwd:
4189 p = lock_user(arg1, arg2, 0);
4190 ret = get_errno(sys_getcwd1(p, arg2));
4191 unlock_user(p, arg1, ret);
4192 break;
4193 case TARGET_NR_capget:
4194 goto unimplemented;
4195 case TARGET_NR_capset:
4196 goto unimplemented;
4197 case TARGET_NR_sigaltstack:
4198 goto unimplemented;
4199 case TARGET_NR_sendfile:
4200 goto unimplemented;
4201 #ifdef TARGET_NR_getpmsg
4202 case TARGET_NR_getpmsg:
4203 goto unimplemented;
4204 #endif
4205 #ifdef TARGET_NR_putpmsg
4206 case TARGET_NR_putpmsg:
4207 goto unimplemented;
4208 #endif
4209 #ifdef TARGET_NR_vfork
4210 case TARGET_NR_vfork:
4211 ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD, 0));
4212 break;
4213 #endif
4214 #ifdef TARGET_NR_ugetrlimit
4215 case TARGET_NR_ugetrlimit:
4216 {
4217 struct rlimit rlim;
4218 ret = get_errno(getrlimit(arg1, &rlim));
4219 if (!is_error(ret)) {
4220 struct target_rlimit *target_rlim;
4221 lock_user_struct(target_rlim, arg2, 0);
4222 target_rlim->rlim_cur = tswapl(rlim.rlim_cur);
4223 target_rlim->rlim_max = tswapl(rlim.rlim_max);
4224 unlock_user_struct(target_rlim, arg2, 1);
4225 }
4226 break;
4227 }
4228 #endif
4229 #ifdef TARGET_NR_truncate64
4230 case TARGET_NR_truncate64:
4231 p = lock_user_string(arg1);
4232 ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);
4233 unlock_user(p, arg1, 0);
4234 break;
4235 #endif
4236 #ifdef TARGET_NR_ftruncate64
4237 case TARGET_NR_ftruncate64:
4238 ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);
4239 break;
4240 #endif
4241 #ifdef TARGET_NR_stat64
4242 case TARGET_NR_stat64:
4243 p = lock_user_string(arg1);
4244 ret = get_errno(stat(path(p), &st));
4245 unlock_user(p, arg1, 0);
4246 goto do_stat64;
4247 #endif
4248 #ifdef TARGET_NR_lstat64
4249 case TARGET_NR_lstat64:
4250 p = lock_user_string(arg1);
4251 ret = get_errno(lstat(path(p), &st));
4252 unlock_user(p, arg1, 0);
4253 goto do_stat64;
4254 #endif
4255 #ifdef TARGET_NR_fstat64
4256 case TARGET_NR_fstat64:
4257 {
4258 ret = get_errno(fstat(arg1, &st));
4259 do_stat64:
4260 if (!is_error(ret)) {
4261 #ifdef TARGET_ARM
4262 if (((CPUARMState *)cpu_env)->eabi) {
4263 struct target_eabi_stat64 *target_st;
4264 lock_user_struct(target_st, arg2, 1);
4265 memset(target_st, 0, sizeof(struct target_eabi_stat64));
4266 /* put_user is probably wrong. */
4267 put_user(st.st_dev, &target_st->st_dev);
4268 put_user(st.st_ino, &target_st->st_ino);
4269 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
4270 put_user(st.st_ino, &target_st->__st_ino);
4271 #endif
4272 put_user(st.st_mode, &target_st->st_mode);
4273 put_user(st.st_nlink, &target_st->st_nlink);
4274 put_user(st.st_uid, &target_st->st_uid);
4275 put_user(st.st_gid, &target_st->st_gid);
4276 put_user(st.st_rdev, &target_st->st_rdev);
4277 /* XXX: better use of kernel struct */
4278 put_user(st.st_size, &target_st->st_size);
4279 put_user(st.st_blksize, &target_st->st_blksize);
4280 put_user(st.st_blocks, &target_st->st_blocks);
4281 put_user(st.st_atime, &target_st->target_st_atime);
4282 put_user(st.st_mtime, &target_st->target_st_mtime);
4283 put_user(st.st_ctime, &target_st->target_st_ctime);
4284 unlock_user_struct(target_st, arg2, 0);
4285 } else
4286 #endif
4287 {
4288 struct target_stat64 *target_st;
4289 lock_user_struct(target_st, arg2, 1);
4290 memset(target_st, 0, sizeof(struct target_stat64));
4291 /* ??? put_user is probably wrong. */
4292 put_user(st.st_dev, &target_st->st_dev);
4293 put_user(st.st_ino, &target_st->st_ino);
4294 #ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
4295 put_user(st.st_ino, &target_st->__st_ino);
4296 #endif
4297 put_user(st.st_mode, &target_st->st_mode);
4298 put_user(st.st_nlink, &target_st->st_nlink);
4299 put_user(st.st_uid, &target_st->st_uid);
4300 put_user(st.st_gid, &target_st->st_gid);
4301 put_user(st.st_rdev, &target_st->st_rdev);
4302 /* XXX: better use of kernel struct */
4303 put_user(st.st_size, &target_st->st_size);
4304 put_user(st.st_blksize, &target_st->st_blksize);
4305 put_user(st.st_blocks, &target_st->st_blocks);
4306 put_user(st.st_atime, &target_st->target_st_atime);
4307 put_user(st.st_mtime, &target_st->target_st_mtime);
4308 put_user(st.st_ctime, &target_st->target_st_ctime);
4309 unlock_user_struct(target_st, arg2, 0);
4310 }
4311 }
4312 }
4313 break;
4314 #endif
4315 #ifdef USE_UID16
4316 case TARGET_NR_lchown:
4317 p = lock_user_string(arg1);
4318 ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));
4319 unlock_user(p, arg1, 0);
4320 break;
4321 case TARGET_NR_getuid:
4322 ret = get_errno(high2lowuid(getuid()));
4323 break;
4324 case TARGET_NR_getgid:
4325 ret = get_errno(high2lowgid(getgid()));
4326 break;
4327 case TARGET_NR_geteuid:
4328 ret = get_errno(high2lowuid(geteuid()));
4329 break;
4330 case TARGET_NR_getegid:
4331 ret = get_errno(high2lowgid(getegid()));
4332 break;
4333 case TARGET_NR_setreuid:
4334 ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));
4335 break;
4336 case TARGET_NR_setregid:
4337 ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));
4338 break;
4339 case TARGET_NR_getgroups:
4340 {
4341 int gidsetsize = arg1;
4342 uint16_t *target_grouplist;
4343 gid_t *grouplist;
4344 int i;
4345
4346 grouplist = alloca(gidsetsize * sizeof(gid_t));
4347 ret = get_errno(getgroups(gidsetsize, grouplist));
4348 if (!is_error(ret)) {
4349 target_grouplist = lock_user(arg2, gidsetsize * 2, 0);
4350 for(i = 0;i < gidsetsize; i++)
4351 target_grouplist[i] = tswap16(grouplist[i]);
4352 unlock_user(target_grouplist, arg2, gidsetsize * 2);
4353 }
4354 }
4355 break;
4356 case TARGET_NR_setgroups:
4357 {
4358 int gidsetsize = arg1;
4359 uint16_t *target_grouplist;
4360 gid_t *grouplist;
4361 int i;
4362
4363 grouplist = alloca(gidsetsize * sizeof(gid_t));
4364 target_grouplist = lock_user(arg2, gidsetsize * 2, 1);
4365 for(i = 0;i < gidsetsize; i++)
4366 grouplist[i] = tswap16(target_grouplist[i]);
4367 unlock_user(target_grouplist, arg2, 0);
4368 ret = get_errno(setgroups(gidsetsize, grouplist));
4369 }
4370 break;
4371 case TARGET_NR_fchown:
4372 ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));
4373 break;
4374 #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)
4375 case TARGET_NR_fchownat:
4376 if (!arg2) {
4377 ret = -EFAULT;
4378 goto fail;
4379 }
4380 p = lock_user_string(arg2);
4381 if (!access_ok(VERIFY_READ, p, 1))
4382 ret = -EFAULT;
4383 else
4384 ret = get_errno(sys_fchownat(arg1, p, low2highuid(arg3), low2highgid(arg4), arg5));
4385 if (p)
4386 unlock_user(p, arg2, 0);
4387 break;
4388 #endif
4389 #ifdef TARGET_NR_setresuid
4390 case TARGET_NR_setresuid:
4391 ret = get_errno(setresuid(low2highuid(arg1),
4392 low2highuid(arg2),
4393 low2highuid(arg3)));
4394 break;
4395 #endif
4396 #ifdef TARGET_NR_getresuid
4397 case TARGET_NR_getresuid:
4398 {
4399 uid_t ruid, euid, suid;
4400 ret = get_errno(getresuid(&ruid, &euid, &suid));
4401 if (!is_error(ret)) {
4402 tput16(arg1, tswap16(high2lowuid(ruid)));
4403 tput16(arg2, tswap16(high2lowuid(euid)));
4404 tput16(arg3, tswap16(high2lowuid(suid)));
4405 }
4406 }
4407 break;
4408 #endif
4409 #ifdef TARGET_NR_getresgid
4410 case TARGET_NR_setresgid:
4411 ret = get_errno(setresgid(low2highgid(arg1),
4412 low2highgid(arg2),
4413 low2highgid(arg3)));
4414 break;
4415 #endif
4416 #ifdef TARGET_NR_getresgid
4417 case TARGET_NR_getresgid:
4418 {
4419 gid_t rgid, egid, sgid;
4420 ret = get_errno(getresgid(&rgid, &egid, &sgid));
4421 if (!is_error(ret)) {
4422 tput16(arg1, tswap16(high2lowgid(rgid)));
4423 tput16(arg2, tswap16(high2lowgid(egid)));
4424 tput16(arg3, tswap16(high2lowgid(sgid)));
4425 }
4426 }
4427 break;
4428 #endif
4429 case TARGET_NR_chown:
4430 p = lock_user_string(arg1);
4431 ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));
4432 unlock_user(p, arg1, 0);
4433 break;
4434 case TARGET_NR_setuid:
4435 ret = get_errno(setuid(low2highuid(arg1)));
4436 break;
4437 case TARGET_NR_setgid:
4438 ret = get_errno(setgid(low2highgid(arg1)));
4439 break;
4440 case TARGET_NR_setfsuid:
4441 ret = get_errno(setfsuid(arg1));
4442 break;
4443 case TARGET_NR_setfsgid:
4444 ret = get_errno(setfsgid(arg1));
4445 break;
4446 #endif /* USE_UID16 */
4447
4448 #ifdef TARGET_NR_lchown32
4449 case TARGET_NR_lchown32:
4450 p = lock_user_string(arg1);
4451 ret = get_errno(lchown(p, arg2, arg3));
4452 unlock_user(p, arg1, 0);
4453 break;
4454 #endif
4455 #ifdef TARGET_NR_getuid32
4456 case TARGET_NR_getuid32:
4457 ret = get_errno(getuid());
4458 break;
4459 #endif
4460 #ifdef TARGET_NR_getgid32
4461 case TARGET_NR_getgid32:
4462 ret = get_errno(getgid());
4463 break;
4464 #endif
4465 #ifdef TARGET_NR_geteuid32
4466 case TARGET_NR_geteuid32:
4467 ret = get_errno(geteuid());
4468 break;
4469 #endif
4470 #ifdef TARGET_NR_getegid32
4471 case TARGET_NR_getegid32:
4472 ret = get_errno(getegid());
4473 break;
4474 #endif
4475 #ifdef TARGET_NR_setreuid32
4476 case TARGET_NR_setreuid32:
4477 ret = get_errno(setreuid(arg1, arg2));
4478 break;
4479 #endif
4480 #ifdef TARGET_NR_setregid32
4481 case TARGET_NR_setregid32:
4482 ret = get_errno(setregid(arg1, arg2));
4483 break;
4484 #endif
4485 #ifdef TARGET_NR_getgroups32
4486 case TARGET_NR_getgroups32:
4487 {
4488 int gidsetsize = arg1;
4489 uint32_t *target_grouplist;
4490 gid_t *grouplist;
4491 int i;
4492
4493 grouplist = alloca(gidsetsize * sizeof(gid_t));
4494 ret = get_errno(getgroups(gidsetsize, grouplist));
4495 if (!is_error(ret)) {
4496 target_grouplist = lock_user(arg2, gidsetsize * 4, 0);
4497 for(i = 0;i < gidsetsize; i++)
4498 target_grouplist[i] = tswap32(grouplist[i]);
4499 unlock_user(target_grouplist, arg2, gidsetsize * 4);
4500 }
4501 }
4502 break;
4503 #endif
4504 #ifdef TARGET_NR_setgroups32
4505 case TARGET_NR_setgroups32:
4506 {
4507 int gidsetsize = arg1;
4508 uint32_t *target_grouplist;
4509 gid_t *grouplist;
4510 int i;
4511
4512 grouplist = alloca(gidsetsize * sizeof(gid_t));
4513 target_grouplist = lock_user(arg2, gidsetsize * 4, 1);
4514 for(i = 0;i < gidsetsize; i++)
4515 grouplist[i] = tswap32(target_grouplist[i]);
4516 unlock_user(target_grouplist, arg2, 0);
4517 ret = get_errno(setgroups(gidsetsize, grouplist));
4518 }
4519 break;
4520 #endif
4521 #ifdef TARGET_NR_fchown32
4522 case TARGET_NR_fchown32:
4523 ret = get_errno(fchown(arg1, arg2, arg3));
4524 break;
4525 #endif
4526 #ifdef TARGET_NR_setresuid32
4527 case TARGET_NR_setresuid32:
4528 ret = get_errno(setresuid(arg1, arg2, arg3));
4529 break;
4530 #endif
4531 #ifdef TARGET_NR_getresuid32
4532 case TARGET_NR_getresuid32:
4533 {
4534 uid_t ruid, euid, suid;
4535 ret = get_errno(getresuid(&ruid, &euid, &suid));
4536 if (!is_error(ret)) {
4537 tput32(arg1, tswap32(ruid));
4538 tput32(arg2, tswap32(euid));
4539 tput32(arg3, tswap32(suid));
4540 }
4541 }
4542 break;
4543 #endif
4544 #ifdef TARGET_NR_setresgid32
4545 case TARGET_NR_setresgid32:
4546 ret = get_errno(setresgid(arg1, arg2, arg3));
4547 break;
4548 #endif
4549 #ifdef TARGET_NR_getresgid32
4550 case TARGET_NR_getresgid32:
4551 {
4552 gid_t rgid, egid, sgid;
4553 ret = get_errno(getresgid(&rgid, &egid, &sgid));
4554 if (!is_error(ret)) {
4555 tput32(arg1, tswap32(rgid));
4556 tput32(arg2, tswap32(egid));
4557 tput32(arg3, tswap32(sgid));
4558 }
4559 }
4560 break;
4561 #endif
4562 #ifdef TARGET_NR_chown32
4563 case TARGET_NR_chown32:
4564 p = lock_user_string(arg1);
4565 ret = get_errno(chown(p, arg2, arg3));
4566 unlock_user(p, arg1, 0);
4567 break;
4568 #endif
4569 #ifdef TARGET_NR_setuid32
4570 case TARGET_NR_setuid32:
4571 ret = get_errno(setuid(arg1));
4572 break;
4573 #endif
4574 #ifdef TARGET_NR_setgid32
4575 case TARGET_NR_setgid32:
4576 ret = get_errno(setgid(arg1));
4577 break;
4578 #endif
4579 #ifdef TARGET_NR_setfsuid32
4580 case TARGET_NR_setfsuid32:
4581 ret = get_errno(setfsuid(arg1));
4582 break;
4583 #endif
4584 #ifdef TARGET_NR_setfsgid32
4585 case TARGET_NR_setfsgid32:
4586 ret = get_errno(setfsgid(arg1));
4587 break;
4588 #endif
4589
4590 case TARGET_NR_pivot_root:
4591 goto unimplemented;
4592 #ifdef TARGET_NR_mincore
4593 case TARGET_NR_mincore:
4594 goto unimplemented;
4595 #endif
4596 #ifdef TARGET_NR_madvise
4597 case TARGET_NR_madvise:
4598 /* A straight passthrough may not be safe because qemu sometimes
4599 turns private flie-backed mappings into anonymous mappings.
4600 This will break MADV_DONTNEED.
4601 This is a hint, so ignoring and returning success is ok. */
4602 ret = get_errno(0);
4603 break;
4604 #endif
4605 #if TARGET_LONG_BITS == 32
4606 case TARGET_NR_fcntl64:
4607 {
4608 int cmd;
4609 struct flock64 fl;
4610 struct target_flock64 *target_fl;
4611 #ifdef TARGET_ARM
4612 struct target_eabi_flock64 *target_efl;
4613 #endif
4614
4615 switch(arg2){
4616 case TARGET_F_GETLK64:
4617 cmd = F_GETLK64;
4618 break;
4619 case TARGET_F_SETLK64:
4620 cmd = F_SETLK64;
4621 break;
4622 case TARGET_F_SETLKW64:
4623 cmd = F_SETLK64;
4624 break;
4625 default:
4626 cmd = arg2;
4627 break;
4628 }
4629
4630 switch(arg2) {
4631 case TARGET_F_GETLK64:
4632 #ifdef TARGET_ARM
4633 if (((CPUARMState *)cpu_env)->eabi) {
4634 lock_user_struct(target_efl, arg3, 1);
4635 fl.l_type = tswap16(target_efl->l_type);
4636 fl.l_whence = tswap16(target_efl->l_whence);
4637 fl.l_start = tswap64(target_efl->l_start);
4638 fl.l_len = tswap64(target_efl->l_len);
4639 fl.l_pid = tswapl(target_efl->l_pid);
4640 unlock_user_struct(target_efl, arg3, 0);
4641 } else
4642 #endif
4643 {
4644 lock_user_struct(target_fl, arg3, 1);
4645 fl.l_type = tswap16(target_fl->l_type);
4646 fl.l_whence = tswap16(target_fl->l_whence);
4647 fl.l_start = tswap64(target_fl->l_start);
4648 fl.l_len = tswap64(target_fl->l_len);
4649 fl.l_pid = tswapl(target_fl->l_pid);
4650 unlock_user_struct(target_fl, arg3, 0);
4651 }
4652 ret = get_errno(fcntl(arg1, cmd, &fl));
4653 if (ret == 0) {
4654 #ifdef TARGET_ARM
4655 if (((CPUARMState *)cpu_env)->eabi) {
4656 lock_user_struct(target_efl, arg3, 0);
4657 target_efl->l_type = tswap16(fl.l_type);
4658 target_efl->l_whence = tswap16(fl.l_whence);
4659 target_efl->l_start = tswap64(fl.l_start);
4660 target_efl->l_len = tswap64(fl.l_len);
4661 target_efl->l_pid = tswapl(fl.l_pid);
4662 unlock_user_struct(target_efl, arg3, 1);
4663 } else
4664 #endif
4665 {
4666 lock_user_struct(target_fl, arg3, 0);
4667 target_fl->l_type = tswap16(fl.l_type);
4668 target_fl->l_whence = tswap16(fl.l_whence);
4669 target_fl->l_start = tswap64(fl.l_start);
4670 target_fl->l_len = tswap64(fl.l_len);
4671 target_fl->l_pid = tswapl(fl.l_pid);
4672 unlock_user_struct(target_fl, arg3, 1);
4673 }
4674 }
4675 break;
4676
4677 case TARGET_F_SETLK64:
4678 case TARGET_F_SETLKW64:
4679 #ifdef TARGET_ARM
4680 if (((CPUARMState *)cpu_env)->eabi) {
4681 lock_user_struct(target_efl, arg3, 1);
4682 fl.l_type = tswap16(target_efl->l_type);
4683 fl.l_whence = tswap16(target_efl->l_whence);
4684 fl.l_start = tswap64(target_efl->l_start);
4685 fl.l_len = tswap64(target_efl->l_len);
4686 fl.l_pid = tswapl(target_efl->l_pid);
4687 unlock_user_struct(target_efl, arg3, 0);
4688 } else
4689 #endif
4690 {
4691 lock_user_struct(target_fl, arg3, 1);
4692 fl.l_type = tswap16(target_fl->l_type);
4693 fl.l_whence = tswap16(target_fl->l_whence);
4694 fl.l_start = tswap64(target_fl->l_start);
4695 fl.l_len = tswap64(target_fl->l_len);
4696 fl.l_pid = tswapl(target_fl->l_pid);
4697 unlock_user_struct(target_fl, arg3, 0);
4698 }
4699 ret = get_errno(fcntl(arg1, cmd, &fl));
4700 break;
4701 default:
4702 ret = get_errno(do_fcntl(arg1, cmd, arg3));
4703 break;
4704 }
4705 break;
4706 }
4707 #endif
4708 #ifdef TARGET_NR_cacheflush
4709 case TARGET_NR_cacheflush:
4710 /* self-modifying code is handled automatically, so nothing needed */
4711 ret = 0;
4712 break;
4713 #endif
4714 #ifdef TARGET_NR_security
4715 case TARGET_NR_security:
4716 goto unimplemented;
4717 #endif
4718 #ifdef TARGET_NR_getpagesize
4719 case TARGET_NR_getpagesize:
4720 ret = TARGET_PAGE_SIZE;
4721 break;
4722 #endif
4723 case TARGET_NR_gettid:
4724 ret = get_errno(gettid());
4725 break;
4726 #ifdef TARGET_NR_readahead
4727 case TARGET_NR_readahead:
4728 goto unimplemented;
4729 #endif
4730 #ifdef TARGET_NR_setxattr
4731 case TARGET_NR_setxattr:
4732 case TARGET_NR_lsetxattr:
4733 case TARGET_NR_fsetxattr:
4734 case TARGET_NR_getxattr:
4735 case TARGET_NR_lgetxattr:
4736 case TARGET_NR_fgetxattr:
4737 case TARGET_NR_listxattr:
4738 case TARGET_NR_llistxattr:
4739 case TARGET_NR_flistxattr:
4740 case TARGET_NR_removexattr:
4741 case TARGET_NR_lremovexattr:
4742 case TARGET_NR_fremovexattr:
4743 goto unimplemented_nowarn;
4744 #endif
4745 #ifdef TARGET_NR_set_thread_area
4746 case TARGET_NR_set_thread_area:
4747 #ifdef TARGET_MIPS
4748 ((CPUMIPSState *) cpu_env)->tls_value = arg1;
4749 ret = 0;
4750 break;
4751 #else
4752 goto unimplemented_nowarn;
4753 #endif
4754 #endif
4755 #ifdef TARGET_NR_get_thread_area
4756 case TARGET_NR_get_thread_area:
4757 goto unimplemented_nowarn;
4758 #endif
4759 #ifdef TARGET_NR_getdomainname
4760 case TARGET_NR_getdomainname:
4761 goto unimplemented_nowarn;
4762 #endif
4763
4764 #ifdef TARGET_NR_clock_gettime
4765 case TARGET_NR_clock_gettime:
4766 {
4767 struct timespec ts;
4768 ret = get_errno(clock_gettime(arg1, &ts));
4769 if (!is_error(ret)) {
4770 host_to_target_timespec(arg2, &ts);
4771 }
4772 break;
4773 }
4774 #endif
4775 #ifdef TARGET_NR_clock_getres
4776 case TARGET_NR_clock_getres:
4777 {
4778 struct timespec ts;
4779 ret = get_errno(clock_getres(arg1, &ts));
4780 if (!is_error(ret)) {
4781 host_to_target_timespec(arg2, &ts);
4782 }
4783 break;
4784 }
4785 #endif
4786
4787 #if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
4788 case TARGET_NR_set_tid_address:
4789 ret = get_errno(set_tid_address((int *) arg1));
4790 break;
4791 #endif
4792
4793 #if defined(TARGET_NR_tkill) && defined(__NR_tkill)
4794 case TARGET_NR_tkill:
4795 ret = get_errno(sys_tkill((int)arg1, (int)arg2));
4796 break;
4797 #endif
4798
4799 #if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
4800 case TARGET_NR_tgkill:
4801 ret = get_errno(sys_tgkill((int)arg1, (int)arg2, (int)arg3));
4802 break;
4803 #endif
4804
4805 #ifdef TARGET_NR_set_robust_list
4806 case TARGET_NR_set_robust_list:
4807 goto unimplemented_nowarn;
4808 #endif
4809
4810 default:
4811 unimplemented:
4812 gemu_log("qemu: Unsupported syscall: %d\n", num);
4813 #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
4814 unimplemented_nowarn:
4815 #endif
4816 ret = -ENOSYS;
4817 break;
4818 }
4819 fail:
4820 #ifdef DEBUG
4821 gemu_log(" = %ld\n", ret);
4822 #endif
4823 return ret;
4824 }
4825
QEMU mirror