| 167 |
167 |
#ifdef __NR_gettid
|
| 168 |
168 |
_syscall0(int, gettid)
|
| 169 |
169 |
#else
|
|
170 |
/* This is a replacement for the host gettid() and must return a host
|
|
171 |
errno. */
|
| 170 |
172 |
static int gettid(void) {
|
| 171 |
173 |
return -ENOSYS;
|
| 172 |
174 |
}
|
| ... | ... | |
| 389 |
391 |
target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
|
| 390 |
392 |
}
|
| 391 |
393 |
|
|
394 |
/* do_brk() must return target values and target errnos. */
|
| 392 |
395 |
abi_long do_brk(abi_ulong new_brk)
|
| 393 |
396 |
{
|
| 394 |
397 |
abi_ulong brk_page;
|
| ... | ... | |
| 398 |
401 |
if (!new_brk)
|
| 399 |
402 |
return target_brk;
|
| 400 |
403 |
if (new_brk < target_original_brk)
|
| 401 |
|
return -ENOMEM;
|
|
404 |
return -TARGET_ENOMEM;
|
| 402 |
405 |
|
| 403 |
406 |
brk_page = HOST_PAGE_ALIGN(target_brk);
|
| 404 |
407 |
|
| ... | ... | |
| 532 |
535 |
}
|
| 533 |
536 |
|
| 534 |
537 |
|
|
538 |
/* do_select() must return target values and target errnos. */
|
| 535 |
539 |
static abi_long do_select(int n,
|
| 536 |
540 |
abi_ulong rfd_p, abi_ulong wfd_p,
|
| 537 |
541 |
abi_ulong efd_p, abi_ulong target_tv)
|
| ... | ... | |
| 706 |
710 |
msgh->msg_controllen = tswapl(space);
|
| 707 |
711 |
}
|
| 708 |
712 |
|
|
713 |
/* do_setsockopt() Must return target values and target errnos. */
|
| 709 |
714 |
static abi_long do_setsockopt(int sockfd, int level, int optname,
|
| 710 |
715 |
abi_ulong optval, socklen_t optlen)
|
| 711 |
716 |
{
|
| ... | ... | |
| 716 |
721 |
case SOL_TCP:
|
| 717 |
722 |
/* TCP options all take an 'int' value. */
|
| 718 |
723 |
if (optlen < sizeof(uint32_t))
|
| 719 |
|
return -EINVAL;
|
|
724 |
return -TARGET_EINVAL;
|
| 720 |
725 |
|
| 721 |
726 |
val = tget32(optval);
|
| 722 |
727 |
ret = get_errno(setsockopt(sockfd, level, optname, &val, sizeof(val)));
|
| ... | ... | |
| 814 |
819 |
goto unimplemented;
|
| 815 |
820 |
}
|
| 816 |
821 |
if (optlen < sizeof(uint32_t))
|
| 817 |
|
return -EINVAL;
|
|
822 |
return -TARGET_EINVAL;
|
| 818 |
823 |
|
| 819 |
824 |
val = tget32(optval);
|
| 820 |
825 |
ret = get_errno(setsockopt(sockfd, SOL_SOCKET, optname, &val, sizeof(val)));
|
| ... | ... | |
| 822 |
827 |
default:
|
| 823 |
828 |
unimplemented:
|
| 824 |
829 |
gemu_log("Unsupported setsockopt level=%d optname=%d \n", level, optname);
|
| 825 |
|
ret = -ENOSYS;
|
|
830 |
ret = -TARGET_ENOSYS;
|
| 826 |
831 |
}
|
| 827 |
832 |
return ret;
|
| 828 |
833 |
}
|
| 829 |
834 |
|
|
835 |
/* do_getsockopt() Must return target values and target errnos. */
|
| 830 |
836 |
static abi_long do_getsockopt(int sockfd, int level, int optname,
|
| 831 |
837 |
abi_ulong optval, abi_ulong optlen)
|
| 832 |
838 |
{
|
| ... | ... | |
| 853 |
859 |
int_case:
|
| 854 |
860 |
len = tget32(optlen);
|
| 855 |
861 |
if (len < 0)
|
| 856 |
|
return -EINVAL;
|
|
862 |
return -TARGET_EINVAL;
|
| 857 |
863 |
lv = sizeof(int);
|
| 858 |
864 |
ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
|
| 859 |
865 |
if (ret < 0)
|
| ... | ... | |
| 886 |
892 |
case IP_MULTICAST_LOOP:
|
| 887 |
893 |
len = tget32(optlen);
|
| 888 |
894 |
if (len < 0)
|
| 889 |
|
return -EINVAL;
|
|
895 |
return -TARGET_EINVAL;
|
| 890 |
896 |
lv = sizeof(int);
|
| 891 |
897 |
ret = get_errno(getsockopt(sockfd, level, optname, &val, &lv));
|
| 892 |
898 |
if (ret < 0)
|
| ... | ... | |
| 910 |
916 |
unimplemented:
|
| 911 |
917 |
gemu_log("getsockopt level=%d optname=%d not yet supported\n",
|
| 912 |
918 |
level, optname);
|
| 913 |
|
ret = -ENOSYS;
|
|
919 |
ret = -TARGET_ENOSYS;
|
| 914 |
920 |
break;
|
| 915 |
921 |
}
|
| 916 |
922 |
return ret;
|
| ... | ... | |
| 947 |
953 |
unlock_user (target_vec, target_addr, 0);
|
| 948 |
954 |
}
|
| 949 |
955 |
|
|
956 |
/* do_socket() Must return target values and target errnos. */
|
| 950 |
957 |
static abi_long do_socket(int domain, int type, int protocol)
|
| 951 |
958 |
{
|
| 952 |
959 |
#if defined(TARGET_MIPS)
|
| ... | ... | |
| 974 |
981 |
return get_errno(socket(domain, type, protocol));
|
| 975 |
982 |
}
|
| 976 |
983 |
|
|
984 |
/* do_bind() Must return target values and target errnos. */
|
| 977 |
985 |
static abi_long do_bind(int sockfd, abi_ulong target_addr,
|
| 978 |
986 |
socklen_t addrlen)
|
| 979 |
987 |
{
|
| ... | ... | |
| 983 |
991 |
return get_errno(bind(sockfd, addr, addrlen));
|
| 984 |
992 |
}
|
| 985 |
993 |
|
|
994 |
/* do_connect() Must return target values and target errnos. */
|
| 986 |
995 |
static abi_long do_connect(int sockfd, abi_ulong target_addr,
|
| 987 |
996 |
socklen_t addrlen)
|
| 988 |
997 |
{
|
| ... | ... | |
| 992 |
1001 |
return get_errno(connect(sockfd, addr, addrlen));
|
| 993 |
1002 |
}
|
| 994 |
1003 |
|
|
1004 |
/* do_sendrecvmsg() Must return target values and target errnos. */
|
| 995 |
1005 |
static abi_long do_sendrecvmsg(int fd, abi_ulong target_msg,
|
| 996 |
1006 |
int flags, int send)
|
| 997 |
1007 |
{
|
| ... | ... | |
| 1035 |
1045 |
return ret;
|
| 1036 |
1046 |
}
|
| 1037 |
1047 |
|
|
1048 |
/* do_accept() Must return target values and target errnos. */
|
| 1038 |
1049 |
static abi_long do_accept(int fd, abi_ulong target_addr,
|
| 1039 |
1050 |
abi_ulong target_addrlen)
|
| 1040 |
1051 |
{
|
| ... | ... | |
| 1050 |
1061 |
return ret;
|
| 1051 |
1062 |
}
|
| 1052 |
1063 |
|
|
1064 |
/* do_getpeername() Must return target values and target errnos. */
|
| 1053 |
1065 |
static abi_long do_getpeername(int fd, abi_ulong target_addr,
|
| 1054 |
1066 |
abi_ulong target_addrlen)
|
| 1055 |
1067 |
{
|
| ... | ... | |
| 1065 |
1077 |
return ret;
|
| 1066 |
1078 |
}
|
| 1067 |
1079 |
|
|
1080 |
/* do_getsockname() Must return target values and target errnos. */
|
| 1068 |
1081 |
static abi_long do_getsockname(int fd, abi_ulong target_addr,
|
| 1069 |
1082 |
abi_ulong target_addrlen)
|
| 1070 |
1083 |
{
|
| ... | ... | |
| 1080 |
1093 |
return ret;
|
| 1081 |
1094 |
}
|
| 1082 |
1095 |
|
|
1096 |
/* do_socketpair() Must return target values and target errnos. */
|
| 1083 |
1097 |
static abi_long do_socketpair(int domain, int type, int protocol,
|
| 1084 |
1098 |
abi_ulong target_tab)
|
| 1085 |
1099 |
{
|
| ... | ... | |
| 1094 |
1108 |
return ret;
|
| 1095 |
1109 |
}
|
| 1096 |
1110 |
|
|
1111 |
/* do_sendto() Must return target values and target errnos. */
|
| 1097 |
1112 |
static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags,
|
| 1098 |
1113 |
abi_ulong target_addr, socklen_t addrlen)
|
| 1099 |
1114 |
{
|
| ... | ... | |
| 1113 |
1128 |
return ret;
|
| 1114 |
1129 |
}
|
| 1115 |
1130 |
|
|
1131 |
/* do_recvfrom() Must return target values and target errnos. */
|
| 1116 |
1132 |
static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags,
|
| 1117 |
1133 |
abi_ulong target_addr,
|
| 1118 |
1134 |
abi_ulong target_addrlen)
|
| ... | ... | |
| 1144 |
1160 |
}
|
| 1145 |
1161 |
|
| 1146 |
1162 |
#ifdef TARGET_NR_socketcall
|
|
1163 |
/* do_socketcall() Must return target values and target errnos. */
|
| 1147 |
1164 |
static abi_long do_socketcall(int num, abi_ulong vptr)
|
| 1148 |
1165 |
{
|
| 1149 |
1166 |
abi_long ret;
|
| ... | ... | |
| 1301 |
1318 |
break;
|
| 1302 |
1319 |
default:
|
| 1303 |
1320 |
gemu_log("Unsupported socketcall: %d\n", num);
|
| 1304 |
|
ret = -ENOSYS;
|
|
1321 |
ret = -TARGET_ENOSYS;
|
| 1305 |
1322 |
break;
|
| 1306 |
1323 |
}
|
| 1307 |
1324 |
return ret;
|
| ... | ... | |
| 1639 |
1656 |
}
|
| 1640 |
1657 |
|
| 1641 |
1658 |
/* ??? This only works with linear mappings. */
|
|
1659 |
/* do_ipc() must return target values and target errnos. */
|
| 1642 |
1660 |
static abi_long do_ipc(unsigned int call, int first,
|
| 1643 |
1661 |
int second, int third,
|
| 1644 |
1662 |
abi_long ptr, abi_long fifth)
|
| ... | ... | |
| 1667 |
1685 |
|
| 1668 |
1686 |
case IPCOP_semtimedop:
|
| 1669 |
1687 |
gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
|
| 1670 |
|
ret = -ENOSYS;
|
|
1688 |
ret = -TARGET_ENOSYS;
|
| 1671 |
1689 |
break;
|
| 1672 |
1690 |
|
| 1673 |
1691 |
case IPCOP_msgget:
|
| ... | ... | |
| 1723 |
1741 |
}
|
| 1724 |
1742 |
}
|
| 1725 |
1743 |
if (put_user(raddr, (abi_ulong *)third))
|
| 1726 |
|
return -EFAULT;
|
|
1744 |
return -TARGET_EFAULT;
|
| 1727 |
1745 |
ret = 0;
|
| 1728 |
1746 |
break;
|
| 1729 |
1747 |
case IPCOP_shmdt:
|
| ... | ... | |
| 1757 |
1775 |
default:
|
| 1758 |
1776 |
unimplemented:
|
| 1759 |
1777 |
gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
|
| 1760 |
|
ret = -ENOSYS;
|
|
1778 |
ret = -TARGET_ENOSYS;
|
| 1761 |
1779 |
break;
|
| 1762 |
1780 |
}
|
| 1763 |
1781 |
return ret;
|
| ... | ... | |
| 1803 |
1821 |
};
|
| 1804 |
1822 |
|
| 1805 |
1823 |
/* ??? Implement proper locking for ioctls. */
|
|
1824 |
/* do_ioctl() Must return target values and target errnos. */
|
| 1806 |
1825 |
static abi_long do_ioctl(int fd, abi_long cmd, abi_long arg)
|
| 1807 |
1826 |
{
|
| 1808 |
1827 |
const IOCTLEntry *ie;
|
| ... | ... | |
| 1816 |
1835 |
for(;;) {
|
| 1817 |
1836 |
if (ie->target_cmd == 0) {
|
| 1818 |
1837 |
gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd);
|
| 1819 |
|
return -ENOSYS;
|
|
1838 |
return -TARGET_ENOSYS;
|
| 1820 |
1839 |
}
|
| 1821 |
1840 |
if (ie->target_cmd == cmd)
|
| 1822 |
1841 |
break;
|
| ... | ... | |
| 1871 |
1890 |
default:
|
| 1872 |
1891 |
gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
|
| 1873 |
1892 |
(long)cmd, arg_type[0]);
|
| 1874 |
|
ret = -ENOSYS;
|
|
1893 |
ret = -TARGET_ENOSYS;
|
| 1875 |
1894 |
break;
|
| 1876 |
1895 |
}
|
| 1877 |
1896 |
return ret;
|
| ... | ... | |
| 2106 |
2125 |
}
|
| 2107 |
2126 |
|
| 2108 |
2127 |
/* XXX: add locking support */
|
|
2128 |
/* write_ldt() returns host errnos */
|
| 2109 |
2129 |
static int write_ldt(CPUX86State *env,
|
| 2110 |
2130 |
abi_ulong ptr, unsigned long bytecount, int oldmode)
|
| 2111 |
2131 |
{
|
| ... | ... | |
| 2188 |
2208 |
}
|
| 2189 |
2209 |
|
| 2190 |
2210 |
/* specific and weird i386 syscalls */
|
|
2211 |
/* do_modify_ldt() returns host errnos (it is inconsistent with the
|
|
2212 |
other do_*() functions which return target errnos). */
|
| 2191 |
2213 |
int do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr, unsigned long bytecount)
|
| 2192 |
2214 |
{
|
| 2193 |
2215 |
int ret = -ENOSYS;
|
| ... | ... | |
| 2220 |
2242 |
return 0;
|
| 2221 |
2243 |
}
|
| 2222 |
2244 |
|
|
2245 |
/* do_fork() Must return host values and target errnos (unlike most
|
|
2246 |
do_*() functions). */
|
| 2223 |
2247 |
int do_fork(CPUState *env, unsigned int flags, abi_ulong newsp)
|
| 2224 |
2248 |
{
|
| 2225 |
2249 |
int ret;
|
| ... | ... | |
| 2547 |
2571 |
unlock_user_struct(target_ts, target_addr, 1);
|
| 2548 |
2572 |
}
|
| 2549 |
2573 |
|
|
2574 |
/* do_syscall() should always have a single exit point at the end so
|
|
2575 |
that actions, such as logging of syscall results, can be performed.
|
|
2576 |
All errnos that do_syscall() returns must be -TARGET_<errcode>. */
|
| 2550 |
2577 |
abi_long do_syscall(void *cpu_env, int num, abi_long arg1,
|
| 2551 |
2578 |
abi_long arg2, abi_long arg3, abi_long arg4,
|
| 2552 |
2579 |
abi_long arg5, abi_long arg6)
|
| ... | ... | |
| 2590 |
2617 |
#if defined(TARGET_NR_openat) && defined(__NR_openat)
|
| 2591 |
2618 |
case TARGET_NR_openat:
|
| 2592 |
2619 |
if (!arg2) {
|
| 2593 |
|
ret = -EFAULT;
|
|
2620 |
ret = -TARGET_EFAULT;
|
| 2594 |
2621 |
goto fail;
|
| 2595 |
2622 |
}
|
| 2596 |
2623 |
p = lock_user_string(arg2);
|
| 2597 |
2624 |
if (!access_ok(VERIFY_READ, p, 1))
|
| 2598 |
|
ret = -EFAULT;
|
|
2625 |
/* Don't "goto fail" so that cleanup can happen. */
|
|
2626 |
ret = -TARGET_EFAULT;
|
| 2599 |
2627 |
else
|
| 2600 |
2628 |
ret = get_errno(sys_openat(arg1,
|
| 2601 |
2629 |
path(p),
|
| ... | ... | |
| 2644 |
2672 |
#if defined(TARGET_NR_linkat) && defined(__NR_linkat)
|
| 2645 |
2673 |
case TARGET_NR_linkat:
|
| 2646 |
2674 |
if (!arg2 || !arg4) {
|
| 2647 |
|
ret = -EFAULT;
|
|
2675 |
ret = -TARGET_EFAULT;
|
| 2648 |
2676 |
goto fail;
|
| 2649 |
|
}
|
|
2677 |
}
|
| 2650 |
2678 |
{
|
| 2651 |
2679 |
void * p2 = NULL;
|
| 2652 |
2680 |
p = lock_user_string(arg2);
|
| 2653 |
2681 |
p2 = lock_user_string(arg4);
|
| 2654 |
2682 |
if (!access_ok(VERIFY_READ, p, 1)
|
| 2655 |
2683 |
|| !access_ok(VERIFY_READ, p2, 1))
|
| 2656 |
|
ret = -EFAULT;
|
|
2684 |
/* Don't "goto fail" so that cleanup can happen. */
|
|
2685 |
ret = -TARGET_EFAULT;
|
| 2657 |
2686 |
else
|
| 2658 |
2687 |
ret = get_errno(sys_linkat(arg1, p, arg3, p2, arg5));
|
| 2659 |
2688 |
if (p2)
|
| ... | ... | |
| 2671 |
2700 |
#if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
|
| 2672 |
2701 |
case TARGET_NR_unlinkat:
|
| 2673 |
2702 |
if (!arg2) {
|
| 2674 |
|
ret = -EFAULT;
|
|
2703 |
ret = -TARGET_EFAULT;
|
| 2675 |
2704 |
goto fail;
|
| 2676 |
2705 |
}
|
| 2677 |
2706 |
p = lock_user_string(arg2);
|
| 2678 |
2707 |
if (!access_ok(VERIFY_READ, p, 1))
|
| 2679 |
|
ret = -EFAULT;
|
|
2708 |
/* Don't "goto fail" so that cleanup can happen. */
|
|
2709 |
ret = -TARGET_EFAULT;
|
| 2680 |
2710 |
else
|
| 2681 |
2711 |
ret = get_errno(sys_unlinkat(arg1, p, arg3));
|
| 2682 |
2712 |
if (p)
|
| ... | ... | |
| 2762 |
2792 |
#if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
|
| 2763 |
2793 |
case TARGET_NR_mknodat:
|
| 2764 |
2794 |
if (!arg2) {
|
| 2765 |
|
ret = -EFAULT;
|
|
2795 |
ret = -TARGET_EFAULT;
|
| 2766 |
2796 |
goto fail;
|
| 2767 |
2797 |
}
|
| 2768 |
2798 |
p = lock_user_string(arg2);
|
| 2769 |
2799 |
if (!access_ok(VERIFY_READ, p, 1))
|
| 2770 |
|
ret = -EFAULT;
|
|
2800 |
/* Don't "goto fail" so that cleanup can happen. */
|
|
2801 |
ret = -TARGET_EFAULT;
|
| 2771 |
2802 |
else
|
| 2772 |
2803 |
ret = get_errno(sys_mknodat(arg1, p, arg3, arg4));
|
| 2773 |
2804 |
if (p)
|
| ... | ... | |
| 2894 |
2925 |
#if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
|
| 2895 |
2926 |
case TARGET_NR_faccessat:
|
| 2896 |
2927 |
if (!arg2) {
|
| 2897 |
|
ret = -EFAULT;
|
|
2928 |
ret = -TARGET_EFAULT;
|
| 2898 |
2929 |
goto fail;
|
| 2899 |
2930 |
}
|
| 2900 |
2931 |
p = lock_user_string(arg2);
|
| 2901 |
2932 |
if (!access_ok(VERIFY_READ, p, 1))
|
| 2902 |
|
ret = -EFAULT;
|
|
2933 |
/* Don't "goto fail" so that cleanup can happen. */
|
|
2934 |
ret = -TARGET_EFAULT;
|
| 2903 |
2935 |
else
|
| 2904 |
2936 |
ret = get_errno(sys_faccessat(arg1, p, arg3, arg4));
|
| 2905 |
2937 |
if (p)
|
| ... | ... | |
| 2935 |
2967 |
#if defined(TARGET_NR_renameat) && defined(__NR_renameat)
|
| 2936 |
2968 |
case TARGET_NR_renameat:
|
| 2937 |
2969 |
if (!arg2 || !arg4) {
|
| 2938 |
|
ret = -EFAULT;
|
| 2939 |
|
goto fail;
|
|
2970 |
ret = -TARGET_EFAULT;
|
|
2971 |
goto fail;
|
| 2940 |
2972 |
}
|
| 2941 |
2973 |
{
|
| 2942 |
2974 |
void *p2 = NULL;
|
| ... | ... | |
| 2944 |
2976 |
p2 = lock_user_string(arg4);
|
| 2945 |
2977 |
if (!access_ok(VERIFY_READ, p, 1)
|
| 2946 |
2978 |
|| !access_ok(VERIFY_READ, p2, 1))
|
| 2947 |
|
ret = -EFAULT;
|
|
2979 |
/* Don't "goto fail" so that cleanup can happen. */
|
|
2980 |
ret = -TARGET_EFAULT;
|
| 2948 |
2981 |
else
|
| 2949 |
2982 |
ret = get_errno(sys_renameat(arg1, p, arg3, p2));
|
| 2950 |
2983 |
if (p2)
|
| ... | ... | |
| 2962 |
2995 |
#if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
|
| 2963 |
2996 |
case TARGET_NR_mkdirat:
|
| 2964 |
2997 |
if (!arg2) {
|
| 2965 |
|
ret = -EFAULT;
|
|
2998 |
ret = -TARGET_EFAULT;
|
| 2966 |
2999 |
goto fail;
|
| 2967 |
3000 |
}
|
| 2968 |
3001 |
p = lock_user_string(arg2);
|
| 2969 |
3002 |
if (!access_ok(VERIFY_READ, p, 1))
|
| 2970 |
|
ret = -EFAULT;
|
|
3003 |
/* Don't "goto fail" so that cleanup can happen. */
|
|
3004 |
ret = -TARGET_EFAULT;
|
| 2971 |
3005 |
else
|
| 2972 |
3006 |
ret = get_errno(sys_mkdirat(arg1, p, arg3));
|
| 2973 |
3007 |
if (p)
|
| ... | ... | |
| 3202 |
3236 |
how = SIG_SETMASK;
|
| 3203 |
3237 |
break;
|
| 3204 |
3238 |
default:
|
| 3205 |
|
ret = -EINVAL;
|
|
3239 |
ret = -TARGET_EINVAL;
|
| 3206 |
3240 |
goto fail;
|
| 3207 |
3241 |
}
|
| 3208 |
3242 |
p = lock_user(arg2, sizeof(target_sigset_t), 1);
|
| ... | ... | |
| 3239 |
3273 |
how = SIG_SETMASK;
|
| 3240 |
3274 |
break;
|
| 3241 |
3275 |
default:
|
| 3242 |
|
ret = -EINVAL;
|
|
3276 |
ret = -TARGET_EINVAL;
|
| 3243 |
3277 |
goto fail;
|
| 3244 |
3278 |
}
|
| 3245 |
3279 |
p = lock_user(arg2, sizeof(target_sigset_t), 1);
|
| ... | ... | |
| 3434 |
3468 |
#if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
|
| 3435 |
3469 |
case TARGET_NR_symlinkat:
|
| 3436 |
3470 |
if (!arg1 || !arg3) {
|
| 3437 |
|
ret = -EFAULT;
|
| 3438 |
|
goto fail;
|
| 3439 |
|
}
|
|
3471 |
ret = -TARGET_EFAULT;
|
|
3472 |
goto fail;
|
|
3473 |
}
|
| 3440 |
3474 |
{
|
| 3441 |
3475 |
void *p2 = NULL;
|
| 3442 |
3476 |
p = lock_user_string(arg1);
|
| 3443 |
3477 |
p2 = lock_user_string(arg3);
|
| 3444 |
3478 |
if (!access_ok(VERIFY_READ, p, 1)
|
| 3445 |
3479 |
|| !access_ok(VERIFY_READ, p2, 1))
|
| 3446 |
|
ret = -EFAULT;
|
|
3480 |
/* Don't "goto fail" so that cleanup can happen. */
|
|
3481 |
ret = -TARGET_EFAULT;
|
| 3447 |
3482 |
else
|
| 3448 |
3483 |
ret = get_errno(sys_symlinkat(p, arg2, p2));
|
| 3449 |
3484 |
if (p2)
|
| ... | ... | |
| 3470 |
3505 |
#if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
|
| 3471 |
3506 |
case TARGET_NR_readlinkat:
|
| 3472 |
3507 |
if (!arg2 || !arg3) {
|
| 3473 |
|
ret = -EFAULT;
|
|
3508 |
ret = -TARGET_EFAULT;
|
| 3474 |
3509 |
goto fail;
|
| 3475 |
|
}
|
|
3510 |
}
|
| 3476 |
3511 |
{
|
| 3477 |
3512 |
void *p2 = NULL;
|
| 3478 |
3513 |
p = lock_user_string(arg2);
|
| 3479 |
3514 |
p2 = lock_user(arg3, arg4, 0);
|
| 3480 |
3515 |
if (!access_ok(VERIFY_READ, p, 1)
|
| 3481 |
3516 |
|| !access_ok(VERIFY_READ, p2, 1))
|
| 3482 |
|
ret = -EFAULT;
|
|
3517 |
/* Don't "goto fail" so that cleanup can happen. */
|
|
3518 |
ret = -TARGET_EFAULT;
|
| 3483 |
3519 |
else
|
| 3484 |
3520 |
ret = get_errno(sys_readlinkat(arg1, path(p), p2, arg4));
|
| 3485 |
3521 |
if (p2)
|
| ... | ... | |
| 3596 |
3632 |
#if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
|
| 3597 |
3633 |
case TARGET_NR_fchmodat:
|
| 3598 |
3634 |
if (!arg2) {
|
| 3599 |
|
ret = -EFAULT;
|
|
3635 |
ret = -TARGET_EFAULT;
|
| 3600 |
3636 |
goto fail;
|
| 3601 |
3637 |
}
|
| 3602 |
3638 |
p = lock_user_string(arg2);
|
| 3603 |
3639 |
if (!access_ok(VERIFY_READ, p, 1))
|
| 3604 |
|
ret = -EFAULT;
|
|
3640 |
/* Don't "goto fail" so that cleanup can happen. */
|
|
3641 |
ret = -TARGET_EFAULT;
|
| 3605 |
3642 |
else
|
| 3606 |
3643 |
ret = get_errno(sys_fchmodat(arg1, p, arg3, arg4));
|
| 3607 |
3644 |
if (p)
|
| ... | ... | |
| 4055 |
4092 |
abi_long count = arg3;
|
| 4056 |
4093 |
|
| 4057 |
4094 |
dirp = malloc(count);
|
| 4058 |
|
if (!dirp)
|
| 4059 |
|
return -ENOMEM;
|
|
4095 |
if (!dirp) {
|
|
4096 |
ret = -TARGET_EFAULT;
|
|
4097 |
goto fail;
|
|
4098 |
}
|
| 4060 |
4099 |
|
| 4061 |
4100 |
ret = get_errno(sys_getdents(arg1, dirp, count));
|
| 4062 |
4101 |
if (!is_error(ret)) {
|
| ... | ... | |
| 4213 |
4252 |
break;
|
| 4214 |
4253 |
#endif
|
| 4215 |
4254 |
case TARGET_NR__sysctl:
|
| 4216 |
|
/* We don't implement this, but ENODIR is always a safe
|
|
4255 |
/* We don't implement this, but ENOTDIR is always a safe
|
| 4217 |
4256 |
return value. */
|
| 4218 |
|
return -ENOTDIR;
|
|
4257 |
ret = -TARGET_ENOTDIR;
|
|
4258 |
break;
|
| 4219 |
4259 |
case TARGET_NR_sched_setparam:
|
| 4220 |
4260 |
{
|
| 4221 |
4261 |
struct sched_param *target_schp;
|
| ... | ... | |
| 4514 |
4554 |
#if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)
|
| 4515 |
4555 |
case TARGET_NR_fchownat:
|
| 4516 |
4556 |
if (!arg2) {
|
| 4517 |
|
ret = -EFAULT;
|
|
4557 |
ret = -TARGET_EFAULT;
|
| 4518 |
4558 |
goto fail;
|
| 4519 |
4559 |
}
|
| 4520 |
4560 |
p = lock_user_string(arg2);
|
| 4521 |
4561 |
if (!access_ok(VERIFY_READ, p, 1))
|
| 4522 |
|
ret = -EFAULT;
|
|
4562 |
/* Don't "goto fail" so that cleanup can happen. */
|
|
4563 |
ret = -TARGET_EFAULT;
|
| 4523 |
4564 |
else
|
| 4524 |
4565 |
ret = get_errno(sys_fchownat(arg1, p, low2highuid(arg3), low2highgid(arg4), arg5));
|
| 4525 |
4566 |
if (p)
|
| ... | ... | |
| 4958 |
4999 |
else {
|
| 4959 |
5000 |
p = lock_user_string(arg2);
|
| 4960 |
5001 |
if (!access_ok(VERIFY_READ, p, 1))
|
| 4961 |
|
ret = -EFAULT;
|
|
5002 |
/* Don't "goto fail" so that cleanup can happen. */
|
|
5003 |
ret = -TARGET_EFAULT;
|
| 4962 |
5004 |
else
|
| 4963 |
5005 |
ret = get_errno(sys_utimensat(arg1, path(p), ts, arg4));
|
| 4964 |
5006 |
if (p)
|
| ... | ... | |
| 4974 |
5016 |
#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
|
| 4975 |
5017 |
unimplemented_nowarn:
|
| 4976 |
5018 |
#endif
|
| 4977 |
|
ret = -ENOSYS;
|
|
5019 |
ret = -TARGET_ENOSYS;
|
| 4978 |
5020 |
break;
|
| 4979 |
5021 |
}
|
| 4980 |
5022 |
fail:
|