syscall.c (5cd4393b14b68a4e80a3ffa74c04efff2b9590a5) syscall.c (7854b05654b49c2197faef358e3ec1a7559797b9)
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

--- 12 unchanged lines hidden (view full) ---

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

--- 12 unchanged lines hidden (view full) ---

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>
29#include <sys/types.h>
30#include <sys/wait.h>
31#include <sys/time.h>
32#include <sys/stat.h>
33#include <sys/mount.h>
34#include <sys/resource.h>
35#include <sys/mman.h>
36#include <sys/swap.h>
37#include <signal.h>
38#include <sched.h>
39#include <sys/socket.h>
40#include <sys/uio.h>
41#include <sys/poll.h>
42//#include <sys/user.h>
30#include <sys/types.h>
31#include <sys/wait.h>
32#include <sys/time.h>
33#include <sys/stat.h>
34#include <sys/mount.h>
35#include <sys/resource.h>
36#include <sys/mman.h>
37#include <sys/swap.h>
38#include <signal.h>
39#include <sched.h>
40#include <sys/socket.h>
41#include <sys/uio.h>
42#include <sys/poll.h>
43//#include <sys/user.h>
44#include <netinet/tcp.h>
43
44#define termios host_termios
45#define winsize host_winsize
46#define termio host_termio
47#define sgttyb host_sgttyb /* same as target */
48#define tchars host_tchars /* same as target */
49#define ltchars host_ltchars /* same as target */
50

--- 110 unchanged lines hidden (view full) ---

161 target_brk = new_brk;
162 return (long)target_brk;
163 }
164}
165
166static inline fd_set *target_to_host_fds(fd_set *fds,
167 target_long *target_fds, int n)
168{
45
46#define termios host_termios
47#define winsize host_winsize
48#define termio host_termio
49#define sgttyb host_sgttyb /* same as target */
50#define tchars host_tchars /* same as target */
51#define ltchars host_ltchars /* same as target */
52

--- 110 unchanged lines hidden (view full) ---

163 target_brk = new_brk;
164 return (long)target_brk;
165 }
166}
167
168static inline fd_set *target_to_host_fds(fd_set *fds,
169 target_long *target_fds, int n)
170{
169#if !defined(BSWP_NEEDED) && !defined(WORD_BIGENDIAN)
171#if !defined(BSWAP_NEEDED) && !defined(WORDS_BIGENDIAN)
170 return (fd_set *)target_fds;
171#else
172 int i, b;
173 if (target_fds) {
174 FD_ZERO(fds);
175 for(i = 0;i < n; i++) {
176 b = (tswapl(target_fds[i / TARGET_LONG_BITS]) >>
177 (i & (TARGET_LONG_BITS - 1))) & 1;

--- 5 unchanged lines hidden (view full) ---

183 return NULL;
184 }
185#endif
186}
187
188static inline void host_to_target_fds(target_long *target_fds,
189 fd_set *fds, int n)
190{
172 return (fd_set *)target_fds;
173#else
174 int i, b;
175 if (target_fds) {
176 FD_ZERO(fds);
177 for(i = 0;i < n; i++) {
178 b = (tswapl(target_fds[i / TARGET_LONG_BITS]) >>
179 (i & (TARGET_LONG_BITS - 1))) & 1;

--- 5 unchanged lines hidden (view full) ---

185 return NULL;
186 }
187#endif
188}
189
190static inline void host_to_target_fds(target_long *target_fds,
191 fd_set *fds, int n)
192{
191#if !defined(BSWP_NEEDED) && !defined(WORD_BIGENDIAN)
193#if !defined(BSWAP_NEEDED) && !defined(WORDS_BIGENDIAN)
192 /* nothing to do */
193#else
194 int i, nw, j, k;
195 target_long v;
196
197 if (target_fds) {
198 nw = n / TARGET_LONG_BITS;
199 k = 0;

--- 51 unchanged lines hidden (view full) ---

251
252 if (target_tv) {
253 host_to_target_timeval(target_tv, &tv);
254 }
255 }
256 return ret;
257}
258
194 /* nothing to do */
195#else
196 int i, nw, j, k;
197 target_long v;
198
199 if (target_fds) {
200 nw = n / TARGET_LONG_BITS;
201 k = 0;

--- 51 unchanged lines hidden (view full) ---

253
254 if (target_tv) {
255 host_to_target_timeval(target_tv, &tv);
256 }
257 }
258 return ret;
259}
260
259static long do_socketcall(int num, long *vptr)
261static inline void target_to_host_sockaddr(struct sockaddr *addr,
262 struct target_sockaddr *target_addr,
263 socklen_t len)
260{
264{
265 memcpy(addr, target_addr, len);
266 addr->sa_family = tswap16(target_addr->sa_family);
267}
268
269static inline void host_to_target_sockaddr(struct target_sockaddr *target_addr,
270 struct sockaddr *addr,
271 socklen_t len)
272{
273 memcpy(target_addr, addr, len);
274 target_addr->sa_family = tswap16(addr->sa_family);
275}
276
277static inline void target_to_host_cmsg(struct msghdr *msgh,
278 struct target_msghdr *target_msgh)
279{
280 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
281 struct target_cmsghdr *target_cmsg = TARGET_CMSG_FIRSTHDR(target_msgh);
282 socklen_t space = 0;
283
284 while (cmsg && target_cmsg) {
285 void *data = CMSG_DATA(cmsg);
286 void *target_data = TARGET_CMSG_DATA(target_cmsg);
287
288 int len = tswapl(target_cmsg->cmsg_len)
289 - TARGET_CMSG_ALIGN(sizeof (struct target_cmsghdr));
290
291 space += CMSG_SPACE(len);
292 if (space > msgh->msg_controllen) {
293 space -= CMSG_SPACE(len);
294 gemu_log("Host cmsg overflow");
295 break;
296 }
297
298 cmsg->cmsg_level = tswap32(target_cmsg->cmsg_level);
299 cmsg->cmsg_type = tswap32(target_cmsg->cmsg_type);
300 cmsg->cmsg_len = CMSG_LEN(len);
301
302 if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
303 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
304 memcpy(data, target_data, len);
305 } else {
306 int *fd = (int *)data;
307 int *target_fd = (int *)target_data;
308 int i, numfds = len / sizeof(int);
309
310 for (i = 0; i < numfds; i++)
311 fd[i] = tswap32(target_fd[i]);
312 }
313
314 cmsg = CMSG_NXTHDR(msgh, cmsg);
315 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
316 }
317
318 msgh->msg_controllen = space;
319}
320
321static inline void host_to_target_cmsg(struct target_msghdr *target_msgh,
322 struct msghdr *msgh)
323{
324 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msgh);
325 struct target_cmsghdr *target_cmsg = TARGET_CMSG_FIRSTHDR(target_msgh);
326 socklen_t space = 0;
327
328 while (cmsg && target_cmsg) {
329 void *data = CMSG_DATA(cmsg);
330 void *target_data = TARGET_CMSG_DATA(target_cmsg);
331
332 int len = cmsg->cmsg_len - CMSG_ALIGN(sizeof (struct cmsghdr));
333
334 space += TARGET_CMSG_SPACE(len);
335 if (space > tswapl(target_msgh->msg_controllen)) {
336 space -= TARGET_CMSG_SPACE(len);
337 gemu_log("Target cmsg overflow");
338 break;
339 }
340
341 target_cmsg->cmsg_level = tswap32(cmsg->cmsg_level);
342 target_cmsg->cmsg_type = tswap32(cmsg->cmsg_type);
343 target_cmsg->cmsg_len = tswapl(TARGET_CMSG_LEN(len));
344
345 if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
346 gemu_log("Unsupported ancillary data: %d/%d\n", cmsg->cmsg_level, cmsg->cmsg_type);
347 memcpy(target_data, data, len);
348 } else {
349 int *fd = (int *)data;
350 int *target_fd = (int *)target_data;
351 int i, numfds = len / sizeof(int);
352
353 for (i = 0; i < numfds; i++)
354 target_fd[i] = tswap32(fd[i]);
355 }
356
357 cmsg = CMSG_NXTHDR(msgh, cmsg);
358 target_cmsg = TARGET_CMSG_NXTHDR(target_msgh, target_cmsg);
359 }
360
361 msgh->msg_controllen = tswapl(space);
362}
363
364static long do_setsockopt(int sockfd, int level, int optname,
365 void *optval, socklen_t optlen)
366{
367 if (level == SOL_TCP) {
368 /* TCP options all take an 'int' value. */
369 int val;
370
371 if (optlen < sizeof(uint32_t))
372 return -EINVAL;
373
374 val = tswap32(*(uint32_t *)optval);
375 return get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
376 }
377
378 else if (level != SOL_SOCKET) {
379 gemu_log("Unsupported setsockopt level: %d\n", level);
380 return -ENOSYS;
381 }
382
383 switch (optname) {
384 /* Options with 'int' argument. */
385 case SO_DEBUG:
386 case SO_REUSEADDR:
387 case SO_TYPE:
388 case SO_ERROR:
389 case SO_DONTROUTE:
390 case SO_BROADCAST:
391 case SO_SNDBUF:
392 case SO_RCVBUF:
393 case SO_KEEPALIVE:
394 case SO_OOBINLINE:
395 case SO_NO_CHECK:
396 case SO_PRIORITY:
397 case SO_BSDCOMPAT:
398 case SO_PASSCRED:
399 case SO_TIMESTAMP:
400 case SO_RCVLOWAT:
401 case SO_RCVTIMEO:
402 case SO_SNDTIMEO:
403 {
404 int val;
405 if (optlen < sizeof(uint32_t))
406 return -EINVAL;
407 val = tswap32(*(uint32_t *)optval);
408 return get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
409 }
410
411 default:
412 gemu_log("Unsupported setsockopt SOL_SOCKET option: %d\n", optname);
413 return -ENOSYS;
414 }
415}
416
417static long do_getsockopt(int sockfd, int level, int optname,
418 void *optval, socklen_t *optlen)
419{
420 gemu_log("getsockopt not yet supported\n");
421 return -ENOSYS;
422}
423
424static long do_socketcall(int num, int32_t *vptr)
425{
261 long ret;
262
263 switch(num) {
264 case SOCKOP_socket:
426 long ret;
427
428 switch(num) {
429 case SOCKOP_socket:
265 ret = get_errno(socket(vptr[0], vptr[1], vptr[2]));
430 {
431 int domain = tswap32(vptr[0]);
432 int type = tswap32(vptr[1]);
433 int protocol = tswap32(vptr[2]);
434
435 ret = get_errno(socket(domain, type, protocol));
436 }
266 break;
267 case SOCKOP_bind:
437 break;
438 case SOCKOP_bind:
268 ret = get_errno(bind(vptr[0], (struct sockaddr *)vptr[1], vptr[2]));
439 {
440 int sockfd = tswap32(vptr[0]);
441 void *target_addr = (void *)tswap32(vptr[1]);
442 socklen_t addrlen = tswap32(vptr[2]);
443 void *addr = alloca(addrlen);
444
445 target_to_host_sockaddr(addr, target_addr, addrlen);
446 ret = get_errno(bind(sockfd, addr, addrlen));
447 }
269 break;
270 case SOCKOP_connect:
448 break;
449 case SOCKOP_connect:
271 ret = get_errno(connect(vptr[0], (struct sockaddr *)vptr[1], vptr[2]));
450 {
451 int sockfd = tswap32(vptr[0]);
452 void *target_addr = (void *)tswap32(vptr[1]);
453 socklen_t addrlen = tswap32(vptr[2]);
454 void *addr = alloca(addrlen);
455
456 target_to_host_sockaddr(addr, target_addr, addrlen);
457 ret = get_errno(connect(sockfd, addr, addrlen));
458 }
272 break;
273 case SOCKOP_listen:
459 break;
460 case SOCKOP_listen:
274 ret = get_errno(listen(vptr[0], vptr[1]));
461 {
462 int sockfd = tswap32(vptr[0]);
463 int backlog = tswap32(vptr[1]);
464
465 ret = get_errno(listen(sockfd, backlog));
466 }
275 break;
276 case SOCKOP_accept:
277 {
467 break;
468 case SOCKOP_accept:
469 {
278 socklen_t size;
279 size = tswap32(*(int32_t *)vptr[2]);
280 ret = get_errno(accept(vptr[0], (struct sockaddr *)vptr[1], &size));
281 if (!is_error(ret))
282 *(int32_t *)vptr[2] = size;
470 int sockfd = tswap32(vptr[0]);
471 void *target_addr = (void *)tswap32(vptr[1]);
472 uint32_t *target_addrlen = (void *)tswap32(vptr[2]);
473 socklen_t addrlen = tswap32(*target_addrlen);
474 void *addr = alloca(addrlen);
475
476 ret = get_errno(accept(sockfd, addr, &addrlen));
477 if (!is_error(ret)) {
478 host_to_target_sockaddr(target_addr, addr, addrlen);
479 *target_addrlen = tswap32(addrlen);
480 }
283 }
284 break;
285 case SOCKOP_getsockname:
286 {
481 }
482 break;
483 case SOCKOP_getsockname:
484 {
287 socklen_t size;
288 size = tswap32(*(int32_t *)vptr[2]);
289 ret = get_errno(getsockname(vptr[0], (struct sockaddr *)vptr[1], &size));
290 if (!is_error(ret))
291 *(int32_t *)vptr[2] = size;
485 int sockfd = tswap32(vptr[0]);
486 void *target_addr = (void *)tswap32(vptr[1]);
487 uint32_t *target_addrlen = (void *)tswap32(vptr[2]);
488 socklen_t addrlen = tswap32(*target_addrlen);
489 void *addr = alloca(addrlen);
490
491 ret = get_errno(getsockname(sockfd, addr, &addrlen));
492 if (!is_error(ret)) {
493 host_to_target_sockaddr(target_addr, addr, addrlen);
494 *target_addrlen = tswap32(addrlen);
495 }
292 }
293 break;
294 case SOCKOP_getpeername:
295 {
496 }
497 break;
498 case SOCKOP_getpeername:
499 {
296 socklen_t size;
297 size = tswap32(*(int32_t *)vptr[2]);
298 ret = get_errno(getpeername(vptr[0], (struct sockaddr *)vptr[1], &size));
299 if (!is_error(ret))
300 *(int32_t *)vptr[2] = size;
500 int sockfd = tswap32(vptr[0]);
501 void *target_addr = (void *)tswap32(vptr[1]);
502 uint32_t *target_addrlen = (void *)tswap32(vptr[2]);
503 socklen_t addrlen = tswap32(*target_addrlen);
504 void *addr = alloca(addrlen);
505
506 ret = get_errno(getpeername(sockfd, addr, &addrlen));
507 if (!is_error(ret)) {
508 host_to_target_sockaddr(target_addr, addr, addrlen);
509 *target_addrlen = tswap32(addrlen);
510 }
301 }
302 break;
303 case SOCKOP_socketpair:
304 {
511 }
512 break;
513 case SOCKOP_socketpair:
514 {
515 int domain = tswap32(vptr[0]);
516 int type = tswap32(vptr[1]);
517 int protocol = tswap32(vptr[2]);
518 int32_t *target_tab = (void *)tswap32(vptr[3]);
305 int tab[2];
519 int tab[2];
306 int32_t *target_tab = (int32_t *)vptr[3];
307 ret = get_errno(socketpair(vptr[0], vptr[1], vptr[2], tab));
520
521 ret = get_errno(socketpair(domain, type, protocol, tab));
308 if (!is_error(ret)) {
309 target_tab[0] = tswap32(tab[0]);
310 target_tab[1] = tswap32(tab[1]);
311 }
312 }
313 break;
314 case SOCKOP_send:
522 if (!is_error(ret)) {
523 target_tab[0] = tswap32(tab[0]);
524 target_tab[1] = tswap32(tab[1]);
525 }
526 }
527 break;
528 case SOCKOP_send:
315 ret = get_errno(send(vptr[0], (void *)vptr[1], vptr[2], vptr[3]));
529 {
530 int sockfd = tswap32(vptr[0]);
531 void *msg = (void *)tswap32(vptr[1]);
532 size_t len = tswap32(vptr[2]);
533 int flags = tswap32(vptr[3]);
534
535 ret = get_errno(send(sockfd, msg, len, flags));
536 }
316 break;
317 case SOCKOP_recv:
537 break;
538 case SOCKOP_recv:
318 ret = get_errno(recv(vptr[0], (void *)vptr[1], vptr[2], vptr[3]));
539 {
540 int sockfd = tswap32(vptr[0]);
541 void *msg = (void *)tswap32(vptr[1]);
542 size_t len = tswap32(vptr[2]);
543 int flags = tswap32(vptr[3]);
544
545 ret = get_errno(recv(sockfd, msg, len, flags));
546 }
319 break;
320 case SOCKOP_sendto:
547 break;
548 case SOCKOP_sendto:
321 ret = get_errno(sendto(vptr[0], (void *)vptr[1], vptr[2], vptr[3],
322 (struct sockaddr *)vptr[4], vptr[5]));
549 {
550 int sockfd = tswap32(vptr[0]);
551 void *msg = (void *)tswap32(vptr[1]);
552 size_t len = tswap32(vptr[2]);
553 int flags = tswap32(vptr[3]);
554 void *target_addr = (void *)tswap32(vptr[4]);
555 socklen_t addrlen = tswap32(vptr[5]);
556 void *addr = alloca(addrlen);
557
558 target_to_host_sockaddr(addr, target_addr, addrlen);
559 ret = get_errno(sendto(sockfd, msg, len, flags, addr, addrlen));
560 }
323 break;
324 case SOCKOP_recvfrom:
325 {
561 break;
562 case SOCKOP_recvfrom:
563 {
326 socklen_t size;
327 size = tswap32(*(int32_t *)vptr[5]);
328 ret = get_errno(recvfrom(vptr[0], (void *)vptr[1], vptr[2],
329 vptr[3], (struct sockaddr *)vptr[4], &size));
330 if (!is_error(ret))
331 *(int32_t *)vptr[5] = size;
564 int sockfd = tswap32(vptr[0]);
565 void *msg = (void *)tswap32(vptr[1]);
566 size_t len = tswap32(vptr[2]);
567 int flags = tswap32(vptr[3]);
568 void *target_addr = (void *)tswap32(vptr[4]);
569 uint32_t *target_addrlen = (void *)tswap32(vptr[5]);
570 socklen_t addrlen = tswap32(*target_addrlen);
571 void *addr = alloca(addrlen);
572
573 ret = get_errno(recvfrom(sockfd, msg, len, flags, addr, &addrlen));
574 if (!is_error(ret)) {
575 host_to_target_sockaddr(target_addr, addr, addrlen);
576 *target_addrlen = tswap32(addrlen);
577 }
332 }
333 break;
334 case SOCKOP_shutdown:
578 }
579 break;
580 case SOCKOP_shutdown:
335 ret = get_errno(shutdown(vptr[0], vptr[1]));
581 {
582 int sockfd = tswap32(vptr[0]);
583 int how = tswap32(vptr[1]);
584
585 ret = get_errno(shutdown(sockfd, how));
586 }
336 break;
337 case SOCKOP_sendmsg:
338 case SOCKOP_recvmsg:
339 {
340 int fd;
341 struct target_msghdr *msgp;
342 struct msghdr msg;
343 int flags, count, i;
344 struct iovec *vec;
345 struct target_iovec *target_vec;
346
587 break;
588 case SOCKOP_sendmsg:
589 case SOCKOP_recvmsg:
590 {
591 int fd;
592 struct target_msghdr *msgp;
593 struct msghdr msg;
594 int flags, count, i;
595 struct iovec *vec;
596 struct target_iovec *target_vec;
597
347 msgp = (void *)vptr[1];
598 msgp = (void *)tswap32(vptr[1]);
348 msg.msg_name = (void *)tswapl(msgp->msg_name);
349 msg.msg_namelen = tswapl(msgp->msg_namelen);
599 msg.msg_name = (void *)tswapl(msgp->msg_name);
600 msg.msg_namelen = tswapl(msgp->msg_namelen);
350 msg.msg_control = (void *)tswapl(msgp->msg_control);
351 msg.msg_controllen = tswapl(msgp->msg_controllen);
601 msg.msg_controllen = 2 * tswapl(msgp->msg_controllen);
602 msg.msg_control = alloca(msg.msg_controllen);
352 msg.msg_flags = tswap32(msgp->msg_flags);
353
354 count = tswapl(msgp->msg_iovlen);
355 vec = alloca(count * sizeof(struct iovec));
356 target_vec = (void *)tswapl(msgp->msg_iov);
357 for(i = 0;i < count; i++) {
358 vec[i].iov_base = (void *)tswapl(target_vec[i].iov_base);
359 vec[i].iov_len = tswapl(target_vec[i].iov_len);
360 }
361 msg.msg_iovlen = count;
362 msg.msg_iov = vec;
363
603 msg.msg_flags = tswap32(msgp->msg_flags);
604
605 count = tswapl(msgp->msg_iovlen);
606 vec = alloca(count * sizeof(struct iovec));
607 target_vec = (void *)tswapl(msgp->msg_iov);
608 for(i = 0;i < count; i++) {
609 vec[i].iov_base = (void *)tswapl(target_vec[i].iov_base);
610 vec[i].iov_len = tswapl(target_vec[i].iov_len);
611 }
612 msg.msg_iovlen = count;
613 msg.msg_iov = vec;
614
364 fd = vptr[0];
365 flags = vptr[2];
366 if (num == SOCKOP_sendmsg)
367 ret = sendmsg(fd, &msg, flags);
368 else
369 ret = recvmsg(fd, &msg, flags);
370 ret = get_errno(ret);
615 fd = tswap32(vptr[0]);
616 flags = tswap32(vptr[2]);
617 if (num == SOCKOP_sendmsg) {
618 target_to_host_cmsg(&msg, msgp);
619 ret = get_errno(sendmsg(fd, &msg, flags));
620 } else {
621 ret = get_errno(recvmsg(fd, &msg, flags));
622 if (!is_error(ret))
623 host_to_target_cmsg(msgp, &msg);
624 }
371 }
372 break;
373 case SOCKOP_setsockopt:
625 }
626 break;
627 case SOCKOP_setsockopt:
628 {
629 int sockfd = tswap32(vptr[0]);
630 int level = tswap32(vptr[1]);
631 int optname = tswap32(vptr[2]);
632 void *optval = (void *)tswap32(vptr[3]);
633 socklen_t optlen = tswap32(vptr[4]);
634
635 ret = do_setsockopt(sockfd, level, optname, optval, optlen);
636 }
637 break;
374 case SOCKOP_getsockopt:
638 case SOCKOP_getsockopt:
639 {
640 int sockfd = tswap32(vptr[0]);
641 int level = tswap32(vptr[1]);
642 int optname = tswap32(vptr[2]);
643 void *optval = (void *)tswap32(vptr[3]);
644 uint32_t *target_len = (void *)tswap32(vptr[4]);
645 socklen_t optlen = tswap32(*target_len);
646
647 ret = do_getsockopt(sockfd, level, optname, optval, &optlen);
648 if (!is_error(ret))
649 *target_len = tswap32(optlen);
650 }
651 break;
375 default:
376 gemu_log("Unsupported socketcall: %d\n", num);
377 ret = -ENOSYS;
378 break;
379 }
380 return ret;
381}
382

--- 572 unchanged lines hidden (view full) ---

955 break;
956 case TARGET_NR_link:
957 ret = get_errno(link((const char *)arg1, (const char *)arg2));
958 break;
959 case TARGET_NR_unlink:
960 ret = get_errno(unlink((const char *)arg1));
961 break;
962 case TARGET_NR_execve:
652 default:
653 gemu_log("Unsupported socketcall: %d\n", num);
654 ret = -ENOSYS;
655 break;
656 }
657 return ret;
658}
659

--- 572 unchanged lines hidden (view full) ---

1232 break;
1233 case TARGET_NR_link:
1234 ret = get_errno(link((const char *)arg1, (const char *)arg2));
1235 break;
1236 case TARGET_NR_unlink:
1237 ret = get_errno(unlink((const char *)arg1));
1238 break;
1239 case TARGET_NR_execve:
963 ret = get_errno(execve((const char *)arg1, (void *)arg2, (void *)arg3));
1240 {
1241 char **argp, **envp;
1242 int argc = 0, envc = 0;
1243 uint32_t *p;
1244 char **q;
1245
1246 for (p = (void *)arg2; *p; p++)
1247 argc++;
1248 for (p = (void *)arg3; *p; p++)
1249 envc++;
1250
1251 argp = alloca(argc * sizeof(void *));
1252 envp = alloca(envc * sizeof(void *));
1253
1254 for (p = (void *)arg2, q = argp; *p; p++, q++)
1255 *q = (void *)tswap32(*p);
1256 for (p = (void *)arg3, q = envp; *p; p++, q++)
1257 *q = (void *)tswap32(*p);
1258
1259 ret = get_errno(execve((const char *)arg1, argp, envp));
1260 }
964 break;
965 case TARGET_NR_chdir:
966 ret = get_errno(chdir((const char *)arg1));
967 break;
968 case TARGET_NR_time:
969 {
970 int *time_ptr = (int *)arg1;
971 ret = get_errno(time((time_t *)time_ptr));

--- 507 unchanged lines hidden (view full) ---

1479 break;
1480 case TARGET_NR_fstatfs:
1481 stfs = (void *)arg2;
1482 ret = get_errno(sys_fstatfs(arg1, stfs));
1483 goto convert_statfs;
1484 case TARGET_NR_ioperm:
1485 goto unimplemented;
1486 case TARGET_NR_socketcall:
1261 break;
1262 case TARGET_NR_chdir:
1263 ret = get_errno(chdir((const char *)arg1));
1264 break;
1265 case TARGET_NR_time:
1266 {
1267 int *time_ptr = (int *)arg1;
1268 ret = get_errno(time((time_t *)time_ptr));

--- 507 unchanged lines hidden (view full) ---

1776 break;
1777 case TARGET_NR_fstatfs:
1778 stfs = (void *)arg2;
1779 ret = get_errno(sys_fstatfs(arg1, stfs));
1780 goto convert_statfs;
1781 case TARGET_NR_ioperm:
1782 goto unimplemented;
1783 case TARGET_NR_socketcall:
1487 ret = do_socketcall(arg1, (long *)arg2);
1784 ret = do_socketcall(arg1, (int32_t *)arg2);
1488 break;
1489 case TARGET_NR_syslog:
1490 goto unimplemented;
1491 case TARGET_NR_setitimer:
1492 {
1493 struct target_itimerval *target_value = (void *)arg2;
1494 struct target_itimerval *target_ovalue = (void *)arg3;
1495 struct itimerval value, ovalue, *pvalue;

--- 47 unchanged lines hidden (view full) ---

1543 target_st->st_mode = tswap16(st.st_mode);
1544 target_st->st_nlink = tswap16(st.st_nlink);
1545 target_st->st_uid = tswap16(st.st_uid);
1546 target_st->st_gid = tswap16(st.st_gid);
1547 target_st->st_rdev = tswap16(st.st_rdev);
1548 target_st->st_size = tswapl(st.st_size);
1549 target_st->st_blksize = tswapl(st.st_blksize);
1550 target_st->st_blocks = tswapl(st.st_blocks);
1785 break;
1786 case TARGET_NR_syslog:
1787 goto unimplemented;
1788 case TARGET_NR_setitimer:
1789 {
1790 struct target_itimerval *target_value = (void *)arg2;
1791 struct target_itimerval *target_ovalue = (void *)arg3;
1792 struct itimerval value, ovalue, *pvalue;

--- 47 unchanged lines hidden (view full) ---

1840 target_st->st_mode = tswap16(st.st_mode);
1841 target_st->st_nlink = tswap16(st.st_nlink);
1842 target_st->st_uid = tswap16(st.st_uid);
1843 target_st->st_gid = tswap16(st.st_gid);
1844 target_st->st_rdev = tswap16(st.st_rdev);
1845 target_st->st_size = tswapl(st.st_size);
1846 target_st->st_blksize = tswapl(st.st_blksize);
1847 target_st->st_blocks = tswapl(st.st_blocks);
1551 target_st->st_atime = tswapl(st.st_atime);
1552 target_st->st_mtime = tswapl(st.st_mtime);
1553 target_st->st_ctime = tswapl(st.st_ctime);
1848 target_st->target_st_atime = tswapl(st.st_atime);
1849 target_st->target_st_mtime = tswapl(st.st_mtime);
1850 target_st->target_st_ctime = tswapl(st.st_ctime);
1554 }
1555 }
1556 break;
1557 case TARGET_NR_olduname:
1558 goto unimplemented;
1559 case TARGET_NR_iopl:
1560 goto unimplemented;
1561 case TARGET_NR_vhangup:

--- 160 unchanged lines hidden (view full) ---

1722 (void *)arg5);
1723 break;
1724 case TARGET_NR_poll:
1725 {
1726 struct target_pollfd *target_pfd = (void *)arg1;
1727 unsigned int nfds = arg2;
1728 int timeout = arg3;
1729 struct pollfd *pfd;
1851 }
1852 }
1853 break;
1854 case TARGET_NR_olduname:
1855 goto unimplemented;
1856 case TARGET_NR_iopl:
1857 goto unimplemented;
1858 case TARGET_NR_vhangup:

--- 160 unchanged lines hidden (view full) ---

2019 (void *)arg5);
2020 break;
2021 case TARGET_NR_poll:
2022 {
2023 struct target_pollfd *target_pfd = (void *)arg1;
2024 unsigned int nfds = arg2;
2025 int timeout = arg3;
2026 struct pollfd *pfd;
1730 int i;
2027 unsigned int i;
1731
1732 pfd = alloca(sizeof(struct pollfd) * nfds);
1733 for(i = 0; i < nfds; i++) {
1734 pfd[i].fd = tswap32(target_pfd[i].fd);
1735 pfd[i].events = tswap16(target_pfd[i].events);
1736 }
1737 ret = get_errno(poll(pfd, nfds, timeout));
1738 if (!is_error(ret)) {

--- 196 unchanged lines hidden (view full) ---

1935 target_st->st_nlink = tswap16(st.st_nlink);
1936 target_st->st_uid = tswap16(st.st_uid);
1937 target_st->st_gid = tswap16(st.st_gid);
1938 target_st->st_rdev = tswap16(st.st_rdev);
1939 /* XXX: better use of kernel struct */
1940 target_st->st_size = tswapl(st.st_size);
1941 target_st->st_blksize = tswapl(st.st_blksize);
1942 target_st->st_blocks = tswapl(st.st_blocks);
2028
2029 pfd = alloca(sizeof(struct pollfd) * nfds);
2030 for(i = 0; i < nfds; i++) {
2031 pfd[i].fd = tswap32(target_pfd[i].fd);
2032 pfd[i].events = tswap16(target_pfd[i].events);
2033 }
2034 ret = get_errno(poll(pfd, nfds, timeout));
2035 if (!is_error(ret)) {

--- 196 unchanged lines hidden (view full) ---

2232 target_st->st_nlink = tswap16(st.st_nlink);
2233 target_st->st_uid = tswap16(st.st_uid);
2234 target_st->st_gid = tswap16(st.st_gid);
2235 target_st->st_rdev = tswap16(st.st_rdev);
2236 /* XXX: better use of kernel struct */
2237 target_st->st_size = tswapl(st.st_size);
2238 target_st->st_blksize = tswapl(st.st_blksize);
2239 target_st->st_blocks = tswapl(st.st_blocks);
1943 target_st->st_atime = tswapl(st.st_atime);
1944 target_st->st_mtime = tswapl(st.st_mtime);
1945 target_st->st_ctime = tswapl(st.st_ctime);
2240 target_st->target_st_atime = tswapl(st.st_atime);
2241 target_st->target_st_mtime = tswapl(st.st_mtime);
2242 target_st->target_st_ctime = tswapl(st.st_ctime);
1946 }
1947 }
1948 break;
1949
1950 case TARGET_NR_lchown32:
1951 ret = get_errno(lchown((const char *)arg1, arg2, arg3));
1952 break;
1953 case TARGET_NR_getuid32:

--- 120 unchanged lines hidden --- 		2243 }
2244 }
2245 break;
2246
2247 case TARGET_NR_lchown32:
2248 ret = get_errno(lchown((const char *)arg1, arg2, arg3));
2249 break;
2250 case TARGET_NR_getuid32:

--- 120 unchanged lines hidden ---