#define __NR_sys_uname __NR_uname
+#define __NR_sys_faccessat __NR_faccessat
#define __NR_sys_fchmodat __NR_fchmodat
#define __NR_sys_fchownat __NR_fchownat
#define __NR_sys_getcwd1 __NR_getcwd
#define __NR_sys_tgkill __NR_tgkill
#define __NR_sys_tkill __NR_tkill
#define __NR_sys_unlinkat __NR_unlinkat
+#define __NR_sys_utimensat __NR_utimensat
#if defined(__alpha__) || defined (__ia64__) || defined(__x86_64__)
#define __NR__llseek __NR_lseek
}
#endif
_syscall1(int,sys_uname,struct new_utsname *,buf)
+#if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
+_syscall4(int,sys_faccessat,int,dirfd,const char *,pathname,int,mode,int,flags)
+#endif
#if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
_syscall4(int,sys_fchmodat,int,dirfd,const char *,pathname,
mode_t,mode,int,flags)
int,newdirfd,const char *,newpath)
#endif
_syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo)
-#ifdef TARGET_NR_symlinkat
+#if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
_syscall3(int,sys_symlinkat,const char *,oldpath,
int,newdirfd,const char *,newpath)
#endif
#if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
_syscall3(int,sys_unlinkat,int,dirfd,const char *,pathname,int,flags)
#endif
+#if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
+_syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
+ const struct timespec *,tsp,int,flags)
+#endif
extern int personality(int);
extern int flock(int, int);
return err;
}
-static inline long get_errno(long ret)
+static inline target_long get_errno(target_long ret)
{
if (ret == -1)
return -host_to_target_errno(errno);
return ret;
}
-static inline int is_error(long ret)
+static inline int is_error(target_long ret)
{
- return (unsigned long)ret >= (unsigned long)(-4096);
+ return (target_ulong)ret >= (target_ulong)(-4096);
}
static target_ulong target_brk;
target_original_brk = target_brk = HOST_PAGE_ALIGN(new_brk);
}
-long do_brk(target_ulong new_brk)
+target_long do_brk(target_ulong new_brk)
{
target_ulong brk_page;
- long mapped_addr;
+ target_long mapped_addr;
int new_alloc_size;
if (!new_brk)
#define HOST_HZ 100
#endif
-static inline long host_to_target_clock_t(long ticks)
+static inline target_long host_to_target_clock_t(long ticks)
{
#if HOST_HZ == TARGET_HZ
return ticks;
}
-static long do_select(long n,
- target_ulong rfd_p, target_ulong wfd_p,
- target_ulong efd_p, target_ulong target_tv)
+static target_long do_select(int n,
+ target_ulong rfd_p, target_ulong wfd_p,
+ target_ulong efd_p, target_ulong target_tv)
{
fd_set rfds, wfds, efds;
fd_set *rfds_ptr, *wfds_ptr, *efds_ptr;
target_long *target_rfds, *target_wfds, *target_efds;
struct timeval tv, *tv_ptr;
- long ret;
+ target_long ret;
int ok;
if (rfd_p) {
msgh->msg_controllen = tswapl(space);
}
-static long do_setsockopt(int sockfd, int level, int optname,
- target_ulong optval, socklen_t optlen)
+static target_long do_setsockopt(int sockfd, int level, int optname,
+ target_ulong optval, socklen_t optlen)
{
- int val, ret;
+ target_long ret;
+ int val;
switch(level) {
case SOL_TCP:
return ret;
}
-static long do_getsockopt(int sockfd, int level, int optname,
- target_ulong optval, target_ulong optlen)
+static target_long do_getsockopt(int sockfd, int level, int optname,
+ target_ulong optval, target_ulong optlen)
{
- int len, lv, val, ret;
+ target_long ret;
+ int len, lv, val;
switch(level) {
case TARGET_SOL_SOCKET:
unlock_user (target_vec, target_addr, 0);
}
-static long do_socket(int domain, int type, int protocol)
+static target_long do_socket(int domain, int type, int protocol)
{
#if defined(TARGET_MIPS)
switch(type) {
return get_errno(socket(domain, type, protocol));
}
-static long do_bind(int sockfd, target_ulong target_addr,
- socklen_t addrlen)
+static target_long do_bind(int sockfd, target_ulong target_addr,
+ socklen_t addrlen)
{
void *addr = alloca(addrlen);
return get_errno(bind(sockfd, addr, addrlen));
}
-static long do_connect(int sockfd, target_ulong target_addr,
- socklen_t addrlen)
+static target_long do_connect(int sockfd, target_ulong target_addr,
+ socklen_t addrlen)
{
void *addr = alloca(addrlen);
return get_errno(connect(sockfd, addr, addrlen));
}
-static long do_sendrecvmsg(int fd, target_ulong target_msg,
- int flags, int send)
+static target_long do_sendrecvmsg(int fd, target_ulong target_msg,
+ int flags, int send)
{
- long ret;
+ target_long ret;
struct target_msghdr *msgp;
struct msghdr msg;
int count;
return ret;
}
-static long do_accept(int fd, target_ulong target_addr,
- target_ulong target_addrlen)
+static target_long do_accept(int fd, target_ulong target_addr,
+ target_ulong target_addrlen)
{
socklen_t addrlen = tget32(target_addrlen);
void *addr = alloca(addrlen);
- long ret;
+ target_long ret;
ret = get_errno(accept(fd, addr, &addrlen));
if (!is_error(ret)) {
return ret;
}
-static long do_getpeername(int fd, target_ulong target_addr,
- target_ulong target_addrlen)
+static target_long do_getpeername(int fd, target_ulong target_addr,
+ target_ulong target_addrlen)
{
socklen_t addrlen = tget32(target_addrlen);
void *addr = alloca(addrlen);
- long ret;
+ target_long ret;
ret = get_errno(getpeername(fd, addr, &addrlen));
if (!is_error(ret)) {
return ret;
}
-static long do_getsockname(int fd, target_ulong target_addr,
- target_ulong target_addrlen)
+static target_long do_getsockname(int fd, target_ulong target_addr,
+ target_ulong target_addrlen)
{
socklen_t addrlen = tget32(target_addrlen);
void *addr = alloca(addrlen);
- long ret;
+ target_long ret;
ret = get_errno(getsockname(fd, addr, &addrlen));
if (!is_error(ret)) {
return ret;
}
-static long do_socketpair(int domain, int type, int protocol,
- target_ulong target_tab)
+static target_long do_socketpair(int domain, int type, int protocol,
+ target_ulong target_tab)
{
int tab[2];
- long ret;
+ target_long ret;
ret = get_errno(socketpair(domain, type, protocol, tab));
if (!is_error(ret)) {
return ret;
}
-static long do_sendto(int fd, target_ulong msg, size_t len, int flags,
- target_ulong target_addr, socklen_t addrlen)
+static target_long do_sendto(int fd, target_ulong msg, size_t len, int flags,
+ target_ulong target_addr, socklen_t addrlen)
{
void *addr;
void *host_msg;
- long ret;
+ target_long ret;
host_msg = lock_user(msg, len, 1);
if (target_addr) {
return ret;
}
-static long do_recvfrom(int fd, target_ulong msg, size_t len, int flags,
- target_ulong target_addr, target_ulong target_addrlen)
+static target_long do_recvfrom(int fd, target_ulong msg, size_t len, int flags,
+ target_ulong target_addr,
+ target_ulong target_addrlen)
{
socklen_t addrlen;
void *addr;
void *host_msg;
- long ret;
+ target_long ret;
host_msg = lock_user(msg, len, 0);
if (target_addr) {
return ret;
}
-static long do_socketcall(int num, target_ulong vptr)
+#ifdef TARGET_NR_socketcall
+static target_long do_socketcall(int num, target_ulong vptr)
{
- long ret;
+ target_long ret;
const int n = sizeof(target_ulong);
switch(num) {
}
return ret;
}
+#endif
+#ifdef TARGET_NR_ipc
#define N_SHM_REGIONS 32
static struct shm_region {
unsigned short int *array;
};
-static inline void target_to_host_semun(unsigned long cmd,
+static inline void target_to_host_semun(int cmd,
union semun *host_su,
target_ulong target_addr,
struct semid_ds *ds)
}
}
-static inline void host_to_target_semun(unsigned long cmd,
+static inline void host_to_target_semun(int cmd,
target_ulong target_addr,
union semun *host_su,
struct semid_ds *ds)
}
}
-static inline long do_semctl(long first, long second, long third, long ptr)
+static inline target_long do_semctl(int first, int second, int third,
+ target_long ptr)
{
union semun arg;
struct semid_ds dsarg;
int cmd = third&0xff;
- long ret = 0;
+ target_long ret = 0;
switch( cmd ) {
case GETVAL:
};
static inline void target_to_host_msqid_ds(struct msqid_ds *host_md,
- target_ulong target_addr)
+ target_ulong target_addr)
{
struct target_msqid_ds *target_md;
unlock_user_struct(target_md, target_addr, 1);
}
-static inline long do_msgctl(long first, long second, long ptr)
+static inline target_long do_msgctl(int first, int second, target_long ptr)
{
struct msqid_ds dsarg;
int cmd = second&0xff;
- long ret = 0;
+ target_long ret = 0;
switch( cmd ) {
case IPC_STAT:
case IPC_SET:
char mtext[1];
};
-static inline long do_msgsnd(long msqid, long msgp, long msgsz, long msgflg)
+static inline target_long do_msgsnd(int msqid, target_long msgp,
+ unsigned int msgsz, int msgflg)
{
struct target_msgbuf *target_mb;
struct msgbuf *host_mb;
- long ret = 0;
+ target_long ret = 0;
lock_user_struct(target_mb,msgp,0);
host_mb = malloc(msgsz+sizeof(long));
return ret;
}
-static inline long do_msgrcv(long msqid, long msgp, long msgsz, long msgtype, long msgflg)
+static inline target_long do_msgrcv(int msqid, target_long msgp,
+ unsigned int msgsz, int msgtype,
+ int msgflg)
{
struct target_msgbuf *target_mb;
struct msgbuf *host_mb;
- long ret = 0;
+ target_long ret = 0;
lock_user_struct(target_mb, msgp, 0);
host_mb = malloc(msgsz+sizeof(long));
}
/* ??? This only works with linear mappings. */
-static long do_ipc(long call, long first, long second, long third,
- long ptr, long fifth)
+static target_long do_ipc(unsigned int call, int first,
+ int second, int third,
+ target_long ptr, target_long fifth)
{
int version;
- long ret = 0;
+ target_long ret = 0;
unsigned long raddr;
struct shmid_ds shm_info;
int i;
break;
case IPCOP_semtimedop:
- gemu_log("Unsupported ipc call: %ld (version %d)\n", call, version);
+ gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
ret = -ENOSYS;
break;
break;
}
}
- if (put_user(raddr, (uint32_t *)third))
+ if (put_user(raddr, (target_ulong *)third))
return -EFAULT;
ret = 0;
break;
break;
default:
unimplemented:
- gemu_log("Unsupported ipc call: %ld (version %d)\n", call, version);
+ gemu_log("Unsupported ipc call: %d (version %d)\n", call, version);
ret = -ENOSYS;
break;
}
return ret;
}
+#endif
/* kernel structure types definitions */
#define IFNAMSIZ 16
};
/* ??? Implement proper locking for ioctls. */
-static long do_ioctl(long fd, long cmd, long arg)
+static target_long do_ioctl(int fd, target_long cmd, target_long arg)
{
const IOCTLEntry *ie;
const argtype *arg_type;
- long ret;
+ target_long ret;
uint8_t buf_temp[MAX_STRUCT_SIZE];
int target_size;
void *argptr;
ie = ioctl_entries;
for(;;) {
if (ie->target_cmd == 0) {
- gemu_log("Unsupported ioctl: cmd=0x%04lx\n", cmd);
+ gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd);
return -ENOSYS;
}
if (ie->target_cmd == cmd)
}
arg_type = ie->arg_type;
#if defined(DEBUG)
- gemu_log("ioctl: cmd=0x%04lx (%s)\n", cmd, ie->name);
+ gemu_log("ioctl: cmd=0x%04lx (%s)\n", (long)cmd, ie->name);
#endif
switch(arg_type[0]) {
case TYPE_NULL:
}
break;
default:
- gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n", cmd, arg_type[0]);
+ gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n",
+ (long)cmd, arg_type[0]);
ret = -ENOSYS;
break;
}
return 0;
}
-int do_fork(CPUState *env, unsigned int flags, unsigned long newsp)
+int do_fork(CPUState *env, unsigned int flags, target_ulong newsp)
{
int ret;
TaskState *ts;
return ret;
}
-static long do_fcntl(int fd, int cmd, target_ulong arg)
+static target_long do_fcntl(int fd, int cmd, target_ulong arg)
{
struct flock fl;
struct target_flock *target_fl;
struct flock64 fl64;
struct target_flock64 *target_fl64;
- long ret;
+ target_long ret;
switch(cmd) {
case TARGET_F_GETLK:
}
}
+#if TARGET_LONG_BITS == 32
static inline uint64_t target_offset64(uint32_t word0, uint32_t word1)
{
#ifdef TARGET_WORDS_BIG_ENDIAN
return ((uint64_t)word1 << 32) | word0;
#endif
}
+#else /* TARGET_LONG_BITS == 32 */
+static inline uint64_t target_offset64(uint64_t word0, uint64_t word1)
+{
+ return word0;
+}
+#endif /* TARGET_LONG_BITS != 32 */
#ifdef TARGET_NR_truncate64
-static inline long target_truncate64(void *cpu_env, const char *arg1,
- long arg2, long arg3, long arg4)
+static inline target_long target_truncate64(void *cpu_env, const char *arg1,
+ target_long arg2,
+ target_long arg3,
+ target_long arg4)
{
#ifdef TARGET_ARM
if (((CPUARMState *)cpu_env)->eabi)
#endif
#ifdef TARGET_NR_ftruncate64
-static inline long target_ftruncate64(void *cpu_env, long arg1, long arg2,
- long arg3, long arg4)
+static inline target_long target_ftruncate64(void *cpu_env, target_long arg1,
+ target_long arg2,
+ target_long arg3,
+ target_long arg4)
{
#ifdef TARGET_ARM
if (((CPUARMState *)cpu_env)->eabi)
unlock_user_struct(target_ts, target_addr, 1);
}
-long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3,
- long arg4, long arg5, long arg6)
+target_long do_syscall(void *cpu_env, int num, target_long arg1,
+ target_long arg2, target_long arg3, target_long arg4,
+ target_long arg5, target_long arg6)
{
- long ret;
+ target_long ret;
struct stat st;
struct statfs stfs;
void *p;
ret = get_errno(access(p, arg2));
unlock_user(p, arg1, 0);
break;
+#if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
+ case TARGET_NR_faccessat:
+ if (!arg2) {
+ ret = -EFAULT;
+ goto fail;
+ }
+ p = lock_user_string(arg2);
+ if (!access_ok(VERIFY_READ, p, 1))
+ ret = -EFAULT;
+ else
+ ret = get_errno(sys_faccessat(arg1, p, arg3, arg4));
+ if (p)
+ unlock_user(p, arg2, 0);
+ break;
+#endif
#ifdef TARGET_NR_nice /* not on alpha */
case TARGET_NR_nice:
ret = get_errno(nice(arg1));
{
struct target_dirent *target_dirp;
struct dirent *dirp;
- long count = arg3;
+ target_long count = arg3;
dirp = malloc(count);
if (!dirp)
#else
{
struct dirent *dirp;
- long count = arg3;
+ target_long count = arg3;
dirp = lock_user(arg2, count, 0);
ret = get_errno(sys_getdents(arg1, dirp, count));
case TARGET_NR_getdents64:
{
struct dirent64 *dirp;
- long count = arg3;
+ target_long count = arg3;
dirp = lock_user(arg2, count, 0);
ret = get_errno(sys_getdents64(arg1, dirp, count));
if (!is_error(ret)) {
case TARGET_NR_capset:
goto unimplemented;
case TARGET_NR_sigaltstack:
+#if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
+ defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA)
+ ret = do_sigaltstack((struct target_sigaltstack *)arg1,
+ (struct target_sigaltstack *)arg2,
+ get_sp_from_cpustate((CPUState *)cpu_env));
+ break;
+#else
goto unimplemented;
+#endif
case TARGET_NR_sendfile:
goto unimplemented;
#ifdef TARGET_NR_getpmsg
goto unimplemented_nowarn;
#endif
+#if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
+ case TARGET_NR_utimensat:
+ {
+ struct timespec ts[2];
+ target_to_host_timespec(ts, arg3);
+ target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));
+ if (!arg2)
+ ret = get_errno(sys_utimensat(arg1, NULL, ts, arg4));
+ else {
+ p = lock_user_string(arg2);
+ if (!access_ok(VERIFY_READ, p, 1))
+ ret = -EFAULT;
+ else
+ ret = get_errno(sys_utimensat(arg1, path(p), ts, arg4));
+ if (p)
+ unlock_user(p, arg2, 0);
+ }
+ }
+ break;
+#endif
+
default:
unimplemented:
gemu_log("qemu: Unsupported syscall: %d\n", num);
#endif
return ret;
}
-
projects / qemu / blobdiff