misc userland patches [v2]
cover misc userland patches [v2]
From: Riku Voipio <[email protected]>
Resending, now all patches should be independent (with the exception of 0003 which depends on 0004). The guest-base patches are left from the series as Mika is still writing the strace code to be implemented more in the way real strace is done.
Kirill A. Shutemov (2):
Fix fstatat64()/newfstatat() syscall implementation Rewrite mmap_find_vma() to work fine on 64-bit hosts with 32-bit
targets
Lionel Landwerlin (1):
Added posix message queue syscalls except mq_notify
Mika Westerberg (1):
linux-user: removed unnecessary MAX_SOCK_ADDR checks for socket
syscalls
Add support for passing contents of argv0
Riku Voipio (6):
fix IPCOP_sem* and implement sem* Implement shm* syscalls and fix 64/32bit errors
linux-user: unix sockets - fix running dbus Prefer glibc over direct syscalls
linux-user: Proper exit code for uncaught signals
configure | 53 +++ linux-user/main.c | 38 ++- linux-user/mmap.c | 81 ++-- linux-user/qemu.h | 1 + linux-user/signal.c | 37 +- linux-user/strace.list | 12 +- linux-user/syscall.c | 1077 ++++++++++++++++++++++++++++++++++++--------- linux-user/syscall_defs.h | 7 + 8 files changed, 1031 insertions(+), 275 deletions(-)
PATCH 1/10 Fix fstatat64()/newfstatat() syscall implementation
From: Kirill A. Shutemov <[email protected]>
There are two different syscall names for the same goal.
On systems with sizeof(long) == 64 it calls newfstatat. On systems with sizeof(long) == 32 it calls fstatat64.
From: Kirill A. Shutemov <[email protected]>
--- linux-user/syscall.c | 29 +++++++++++++++++++++++++---- 1 files changed, 25 insertions(+), 4 deletions(-)
linux-user/syscall.c +25 -4
@@ -169,6 +169,7 @@ static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \#define __NR_sys_linkat __NR_linkat#define __NR_sys_mkdirat __NR_mkdirat#define __NR_sys_mknodat __NR_mknodat +#define __NR_sys_newfstatat __NR_newfstatat#define __NR_sys_openat __NR_openat#define __NR_sys_readlinkat __NR_readlinkat#define __NR_sys_renameat __NR_renameat
@@ -209,7 +210,8 @@ _syscall4(int,sys_fchmodat,int,dirfd,const char *,pathname, _syscall5(int,sys_fchownat,int,dirfd,const char *,pathname, uid_t,owner,gid_t,group,int,flags)#endif -#if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64) +#if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)) && \ + defined(__NR_fstatat64) _syscall4(int,sys_fstatat64,int,dirfd,const char *,pathname, struct stat *,buf,int,flags)#endif
@@ -240,6 +242,11 @@ _syscall3(int,sys_mkdirat,int,dirfd,const char *,pathname,mode_t,mode) _syscall4(int,sys_mknodat,int,dirfd,const char *,pathname, mode_t,mode,dev_t,dev)#endif +#if (defined(TARGET_NR_newfstatat) || defined(TARGET_NR_fstatat64) ) && \ + defined(__NR_newfstatat) +_syscall4(int,sys_newfstatat,int,dirfd,const char *,pathname, + struct stat *,buf,int,flags) +#endif #if defined(TARGET_NR_openat) && defined(__NR_openat) _syscall4(int,sys_openat,int,dirfd,const char *,pathname,int,flags,mode_t,mode)#endif
@@ -3280,7 +3287,7 @@ static inline abi_long host_to_target_timespec(abi_ulong target_addr,return 0 ; } -#ifdef TARGET_NR_stat64 +#if defined(TARGET_NR_stat64) || defined(TARGET_NR_newfstatat)static inline abi_long host_to_target_stat64 (void *cpu_env,abi_ulong target_addr,struct stat *host_st)
@@ -3312,11 +3319,15 @@ static inline abi_long host_to_target_stat64(void *cpu_env, } else#endif { +#if TARGET_LONG_BITS ==64 +struct target_stat *target_st; +#else struct target_stat64 *target_st; +#endif if (!lock_user_struct (VERIFY_WRITE , target_st, target_addr,0 ))return -TARGET_EFAULT ; -memset (target_st,0 ,sizeof (struct target_stat64 )); +memset (target_st,0 ,sizeof (*target_st));__put_user (host_st->st_dev, &target_st->st_dev);__put_user (host_st->st_ino, &target_st->st_ino);#ifdef TARGET_STAT64_HAS_BROKEN_ST_INO
@@ -5459,11 +5470,21 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1, ret =host_to_target_stat64 (cpu_env, arg2, &st);break ;#endif -#if defined(TARGET_NR_fstatat64) && defined(__NR_fstatat64) +#if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)) && \ + (defined(__NR_fstatat64) || defined(__NR_newfstatat)) +#ifdef TARGET_NR_fstatat64case TARGET_NR_fstatat64: +#endif +#ifdef TARGET_NR_newfstatat +case TARGET_NR_newfstatat: +#endif if (!(p =lock_user_string (arg2))) goto efault; +#ifdef __NR_fstatat64 ret =get_errno (sys_fstatat64 (arg1,path (p), &st, arg4)); +#else + ret =get_errno (sys_newfstatat (arg1,path (p), &st, arg4)); +#endif if (!is_error (ret)) ret =host_to_target_stat64 (cpu_env, arg3, &st);break ;
Signature · 1 line
1.6.2.1
PATCH 2/10 Rewrite mmap_find_vma() to work fine on 64-bit hosts with 32-bit targets
In reply to [email protected]From: Kirill A. Shutemov <[email protected]>
qemu's page table can be incomple if /proc/self/maps is unavailable or host allocating a memory with mmap(), so we can't use it to find free memory area.
New version mmap_find_vma() uses mmap() without MAP_FIXED to find free memory.
From: Kirill A. Shutemov <[email protected]>
--- linux-user/mmap.c | 81 ++++++++++++++++++++++++++++------------------------ linux-user/qemu.h | 1 + 2 files changed, 45 insertions(+), 37 deletions(-)
linux-user/mmap.c +44 -37
@@ -275,52 +275,59 @@ static abi_ulong mmap_next_start = 0x40000000;unsigned long last_brk; -/* find a free memory area of size 'size'. The search starts at -'start'. If 'start' == 0, then a default start address is used. -Return -1 if error. -*/ -/* page_init() marks pages used by the host as reserved to be sure not -to use them. */ -static abi_ulong mmap_find_vma (abi_ulong start,abi_ulong size) +/* +* Find and reserve a free memory area of size 'size'. The search +* starts at 'start'. +* It must be called with mmap_lock() held. +* Return -1 if error. +*/ +abi_ulong mmap_find_vma (abi_ulong start,abi_ulong size) { -abi_ulong addr, addr1, addr_start; -int prot; -unsigned long new_brk; - - new_brk = (unsigned long )sbrk (0 ); -if (last_brk && last_brk < new_brk && last_brk == (target_ulong )last_brk) { -/* This is a hack to catch the host allocating memory with brk(). -If it uses mmap then we loose. -FIXME: We really want to avoid the host allocating memory in -the first place, and maybe leave some slack to avoid switching -to mmap. */ -page_set_flags (last_brk &TARGET_PAGE_MASK , -TARGET_PAGE_ALIGN (new_brk), -PAGE_RESERVED ); - } - last_brk = new_brk; +void *ptr; +abi_ulong addr; size =HOST_PAGE_ALIGN (size); - start = start & qemu_host_page_mask; + start &= qemu_host_page_mask; + +/* If 'start' == 0, then a default start address is used. */ +if (start ==0 ) + start = mmap_next_start; + addr = start; -if (addr ==0 ) - addr = mmap_next_start; - addr_start = addr; +for (;;) { - prot =0 ; -for (addr1 = addr; addr1 < (addr + size); addr1 +=TARGET_PAGE_SIZE ) { - prot |=page_get_flags (addr1); - } -if (prot ==0 ) +/* +* Reserve needed memory area to avoid a race. +* It should be discarded using: +* - mmap() with MAP_FIXED flag +* - mremap() with MREMAP_FIXED flag +* - shmat() with SHM_REMAP flag +*/ + ptr =mmap ((void *)(unsigned long )addr, size,PROT_NONE , +MAP_ANONYMOUS |MAP_PRIVATE |MAP_NORESERVE ,-1 ,0 ); + +/* ENOMEM, if host address space has no memory */ +if (ptr ==MAP_FAILED ) +return (abi_ulong)-1 ; + +/* If address fits target address space we've found what we need */ +if ((unsigned long )ptr + size -1 <= (abi_ulong)-1 )break ; + +/* Unmap and try again with new page */ +munmap (ptr, size); addr += qemu_host_page_size; -/* we found nothing */ -if (addr == addr_start) + +/* ENOMEM if we check whole of target address space */ +if (addr == start)return (abi_ulong)-1 ; } -if (start ==0 ) - mmap_next_start = addr + size; -return addr; + +/* Update default start address */ +if (start == mmap_next_start) + mmap_next_start = (unsigned long )ptr + size; + +return h2g (ptr); }/* NOTE: all the constants are the HOST ones */
linux-user/qemu.h +1 -0
@@ -228,6 +228,7 @@ int target_msync(abi_ulong start, abi_ulong len, int flags);extern unsigned long last_brk;void mmap_lock (void );void mmap_unlock (void ); +abi_ulong mmap_find_vma (abi_ulong ,abi_ulong );void cpu_list_lock (void );void cpu_list_unlock (void );#if defined(USE_NPTL )
Signature · 1 line
1.6.2.1
Re: [Qemu-devel] [PATCH 02/10] Rewrite mmap_find_vma() to work fine on 64-bit hosts with 32-bit targets
Quoted 9 lines · On Sun, Apr 05, 2009 at 11:59:18PM +0300, [email protected] wrote:
From: Kirill A. Shutemov <[email protected]>
qemu's page table can be incomple if
/proc/self/mapsis unavailable or host allocating a memory withmmap(), so we can't use it to find free memory area.New version
mmap_find_vma()usesmmap()withoutMAP_FIXEDto find free memory.
Quoted 8 lines
From: Kirill A. Shutemov <[email protected]>
Signed-off-by Kirill A. Shutemov <[email protected]>Signed-off-by Riku Voipio <[email protected]>--- linux-user/mmap.c | 81 ++++++++++++++++++++++++++++------------------------ linux-user/qemu.h | 1 + 2 files changed, 45 insertions(+), 37 deletions(-)
Last time this patch has been posted, Paul Brook has emitted some concerns about this patch. Paul do you have any more comments about it?
Quoted 119 lines
linux-user/mmap.c +44
-37@@ -275,52 +275,59 @@ static abi_ulong mmap_next_start = 0x40000000;unsigned long last_brk; -/* find a free memory area of size 'size'. The search starts at -'start'. If 'start' == 0, then a default start address is used. -Return -1 if error. -*/ -/* page_init() marks pages used by the host as reserved to be sure not -to use them. */ -static abi_ulong mmap_find_vma (abi_ulong start,abi_ulong size) +/* +* Find and reserve a free memory area of size 'size'. The search +* starts at 'start'. +* It must be called with mmap_lock() held. +* Return -1 if error. +*/ +abi_ulong mmap_find_vma (abi_ulong start,abi_ulong size) { -abi_ulong addr, addr1, addr_start; -int prot; -unsigned long new_brk; - - new_brk = (unsigned long )sbrk (0 ); -if (last_brk && last_brk < new_brk && last_brk == (target_ulong )last_brk) { -/* This is a hack to catch the host allocating memory with brk(). -If it uses mmap then we loose. -FIXME: We really want to avoid the host allocating memory in -the first place, and maybe leave some slack to avoid switching -to mmap. */ -page_set_flags (last_brk &TARGET_PAGE_MASK , -TARGET_PAGE_ALIGN (new_brk), -PAGE_RESERVED ); - } - last_brk = new_brk; +void *ptr; +abi_ulong addr; size =HOST_PAGE_ALIGN (size); - start = start & qemu_host_page_mask; + start &= qemu_host_page_mask; + +/* If 'start' == 0, then a default start address is used. */ +if (start ==0 ) + start = mmap_next_start; + addr = start; -if (addr ==0 ) - addr = mmap_next_start; - addr_start = addr; +for (;;) { - prot =0 ; -for (addr1 = addr; addr1 < (addr + size); addr1 +=TARGET_PAGE_SIZE ) { - prot |=page_get_flags (addr1); - } -if (prot ==0 ) +/* +* Reserve needed memory area to avoid a race. +* It should be discarded using: +* - mmap() with MAP_FIXED flag +* - mremap() with MREMAP_FIXED flag +* - shmat() with SHM_REMAP flag +*/ + ptr =mmap ((void *)(unsigned long )addr, size,PROT_NONE , +MAP_ANONYMOUS |MAP_PRIVATE |MAP_NORESERVE ,-1 ,0 ); + +/* ENOMEM, if host address space has no memory */ +if (ptr ==MAP_FAILED ) +return (abi_ulong)-1 ; + +/* If address fits target address space we've found what we need */ +if ((unsigned long )ptr + size -1 <= (abi_ulong)-1 )break ; + +/* Unmap and try again with new page */ +munmap (ptr, size); addr += qemu_host_page_size; -/* we found nothing */ -if (addr == addr_start) + +/* ENOMEM if we check whole of target address space */ +if (addr == start)return (abi_ulong)-1 ; } -if (start ==0 ) - mmap_next_start = addr + size; -return addr; + +/* Update default start address */ +if (start == mmap_next_start) + mmap_next_start = (unsigned long )ptr + size; + +return h2g (ptr); }/* NOTE: all the constants are the HOST ones */ linux-user/qemu.h +1
-0@@ -228,6 +228,7 @@ int target_msync(abi_ulong start, abi_ulong len, int flags);extern unsigned long last_brk;void mmap_lock (void );void mmap_unlock (void ); +abi_ulong mmap_find_vma (abi_ulong ,abi_ulong );void cpu_list_lock (void );void cpu_list_unlock (void );#if defined(USE_NPTL )Signature · 1 line
1.6.2.1
Signature · 2 lines
Aurelien Jarno GPG: 1024D/F1BCDB73 [email protected] http://www.aurel32.net
PATCH 3/10 Implement shm* syscalls and fix 64/32bit errors
In reply to [email protected]From: Riku Voipio <[email protected]>
Verified with ltp shm* tests. Following test still fails
shmt09 3 FAIL
No regressions were observed on either 64bit or 32bit IA hosts.
Patch based on original patches by:
Kirill A. Shutemov <[email protected]>
- Implement shm* syscalls
- Fix and cleanup IPCOP_shm* ipc calls handling
This patch depends on "Rewrite mmap_find_vma()" patch.
Various whitespace uglifications applied to minimize patch size.
--- linux-user/syscall.c | 299 +++++++++++++++++++++++++++++++++++++++++-------- 1 files changed, 250 insertions(+), 49 deletions(-)
linux-user/syscall.c +250 -49
@@ -1652,14 +1652,12 @@ static abi_long do_socketcall(int num, abi_ulong vptr) }#endif -#ifdef TARGET_NR_ipc#define N_SHM_REGIONS 32static struct shm_region {abi_ulong start;abi_ulong size; } shm_regions[N_SHM_REGIONS ]; -#endif struct target_ipc_perm {
@@ -2152,6 +2150,224 @@ end:return ret; } +struct target_shmid_ds +{ +struct target_ipc_perm shm_perm; +abi_ulong shm_segsz; +abi_ulong shm_atime; +#if TARGET_ABI_BITS ==32 +abi_ulong __unused1; +#endif +abi_ulong shm_dtime; +#if TARGET_ABI_BITS ==32 +abi_ulong __unused2; +#endif +abi_ulong shm_ctime; +#if TARGET_ABI_BITS ==32 +abi_ulong __unused3; +#endif +int shm_cpid; +int shm_lpid; +abi_ulong shm_nattch; +unsigned long int __unused4; +unsigned long int __unused5; +}; + +static inline abi_long target_to_host_shmid_ds (struct shmid_ds *host_sd, +abi_ulong target_addr) +{ +struct target_shmid_ds *target_sd; + +if (!lock_user_struct (VERIFY_READ , target_sd, target_addr,1 )) +return -TARGET_EFAULT ; +if (target_to_host_ipc_perm (&(host_sd->shm_perm), target_addr)) +return -TARGET_EFAULT ; +__put_user (target_sd->shm_segsz, &host_sd->shm_segsz); +__put_user (target_sd->shm_atime, &host_sd->shm_atime); +__put_user (target_sd->shm_dtime, &host_sd->shm_dtime); +__put_user (target_sd->shm_ctime, &host_sd->shm_ctime); +__put_user (target_sd->shm_cpid, &host_sd->shm_cpid); +__put_user (target_sd->shm_lpid, &host_sd->shm_lpid); +__put_user (target_sd->shm_nattch, &host_sd->shm_nattch); +unlock_user_struct (target_sd, target_addr,0 ); +return 0 ; +} + +static inline abi_long host_to_target_shmid_ds (abi_ulong target_addr, +struct shmid_ds *host_sd) +{ +struct target_shmid_ds *target_sd; + +if (!lock_user_struct (VERIFY_WRITE , target_sd, target_addr,0 )) +return -TARGET_EFAULT ; +if (host_to_target_ipc_perm (target_addr, &(host_sd->shm_perm))) +return -TARGET_EFAULT ; +__put_user (host_sd->shm_segsz, &target_sd->shm_segsz); +__put_user (host_sd->shm_atime, &target_sd->shm_atime); +__put_user (host_sd->shm_dtime, &target_sd->shm_dtime); +__put_user (host_sd->shm_ctime, &target_sd->shm_ctime); +__put_user (host_sd->shm_cpid, &target_sd->shm_cpid); +__put_user (host_sd->shm_lpid, &target_sd->shm_lpid); +__put_user (host_sd->shm_nattch, &target_sd->shm_nattch); +unlock_user_struct (target_sd, target_addr,1 ); +return 0 ; +} + +struct target_shminfo { +abi_ulong shmmax; +abi_ulong shmmin; +abi_ulong shmmni; +abi_ulong shmseg; +abi_ulong shmall; +}; + +static inline abi_long host_to_target_shminfo (abi_ulong target_addr, +struct shminfo *host_shminfo) +{ +struct target_shminfo *target_shminfo; +if (!lock_user_struct (VERIFY_WRITE , target_shminfo, target_addr,0 )) +return -TARGET_EFAULT ; +__put_user (host_shminfo->shmmax, &target_shminfo->shmmax); +__put_user (host_shminfo->shmmin, &target_shminfo->shmmin); +__put_user (host_shminfo->shmmni, &target_shminfo->shmmni); +__put_user (host_shminfo->shmseg, &target_shminfo->shmseg); +__put_user (host_shminfo->shmall, &target_shminfo->shmall); +unlock_user_struct (target_shminfo, target_addr,1 ); +return 0 ; +} + +struct target_shm_info { +int used_ids; +abi_ulong shm_tot; +abi_ulong shm_rss; +abi_ulong shm_swp; +abi_ulong swap_attempts; +abi_ulong swap_successes; +}; + +static inline abi_long host_to_target_shm_info (abi_ulong target_addr, +struct shm_info *host_shm_info) +{ +struct target_shm_info *target_shm_info; +if (!lock_user_struct (VERIFY_WRITE , target_shm_info, target_addr,0 )) +return -TARGET_EFAULT ; +__put_user (host_shm_info->used_ids, &target_shm_info->used_ids); +__put_user (host_shm_info->shm_tot, &target_shm_info->shm_tot); +__put_user (host_shm_info->shm_rss, &target_shm_info->shm_rss); +__put_user (host_shm_info->shm_swp, &target_shm_info->shm_swp); +__put_user (host_shm_info->swap_attempts, &target_shm_info->swap_attempts); +__put_user (host_shm_info->swap_successes, &target_shm_info->swap_successes); +unlock_user_struct (target_shm_info, target_addr,1 ); +return 0 ; +} + +static inline abi_long do_shmctl (int shmid,int cmd,abi_long buf) +{ +struct shmid_ds dsarg; +struct shminfo shminfo; +struct shm_info shm_info; +abi_long ret = -TARGET_EINVAL ; + + cmd &=0xff ; + +switch (cmd) { +case IPC_STAT : +case IPC_SET : +case SHM_STAT : +if (target_to_host_shmid_ds (&dsarg, buf)) +return -TARGET_EFAULT ; + ret =get_errno (shmctl (shmid, cmd, &dsarg)); +if (host_to_target_shmid_ds (buf, &dsarg)) +return -TARGET_EFAULT ; +break ; +case IPC_INFO : + ret =get_errno (shmctl (shmid, cmd, (struct shmid_ds *)&shminfo)); +if (host_to_target_shminfo (buf, &shminfo)) +return -TARGET_EFAULT ; +break ; +case SHM_INFO : + ret =get_errno (shmctl (shmid, cmd, (struct shmid_ds *)&shm_info)); +if (host_to_target_shm_info (buf, &shm_info)) +return -TARGET_EFAULT ; +break ; +case IPC_RMID : +case SHM_LOCK : +case SHM_UNLOCK : + ret =get_errno (shmctl (shmid, cmd,NULL )); +break ; + } + +return ret; +} + +static inline abi_ulong do_shmat (int shmid,abi_ulong shmaddr,int shmflg) +{ +abi_long raddr; +void *host_raddr; +struct shmid_ds shm_info; +int i,ret; + +/* find out the length of the shared memory segment */ + ret =get_errno (shmctl (shmid,IPC_STAT , &shm_info)); +if (is_error (ret)) { +/* can't get length, bail out */ +return ret; + } + +mmap_lock (); + +if (shmaddr) + host_raddr =shmat (shmid, (void *)g2h (shmaddr), shmflg); +else { +abi_ulong mmap_start; + + mmap_start =mmap_find_vma (0 , shm_info.shm_segsz); + +if (mmap_start ==-1 ) { + errno =ENOMEM ; + host_raddr = (void *)-1 ; + }else + host_raddr =shmat (shmid,g2h (mmap_start), shmflg |SHM_REMAP ); + } + +if (host_raddr == (void *)-1 ) { +mmap_unlock (); +return get_errno ((long )host_raddr); + } + raddr=h2g ((unsigned long )host_raddr); + +page_set_flags (raddr, raddr + shm_info.shm_segsz, +PAGE_VALID |PAGE_READ | + ((shmflg &SHM_RDONLY )?0 :PAGE_WRITE )); + +for (i =0 ; i <N_SHM_REGIONS ; i++) { +if (shm_regions[i].start ==0 ) { + shm_regions[i].start = raddr; + shm_regions[i].size = shm_info.shm_segsz; +break ; + } + } + +mmap_unlock (); +return raddr; + +} + +static inline abi_long do_shmdt (abi_ulong shmaddr) +{ +int i; + +for (i =0 ; i <N_SHM_REGIONS ; ++i) { +if (shm_regions[i].start == shmaddr) { + shm_regions[i].start =0 ; +page_set_flags (shmaddr, shm_regions[i].size,0 ); +break ; + } + } + +return get_errno (shmdt (g2h (shmaddr))); +} +#ifdef TARGET_NR_ipc/* ??? This only works with linear mappings. */ /* do_ipc() must return target values and target errnos. */
@@ -2161,8 +2377,6 @@ static abi_long do_ipc(unsigned int call, int first, {int version;abi_long ret =0 ; -struct shmid_ds shm_info; -int i; version = call >>16 ; call &=0xffff ;
@@ -2217,48 +2431,24 @@ static abi_long do_ipc(unsigned int call, int first,break ;case IPCOP_shmat: +switch (version) { +default : {abi_ulong raddr; -void *host_addr; -/* SHM_* flags are the same on all linux platforms */ - host_addr =shmat (first, (void *)g2h (ptr), second); -if (host_addr == (void *)-1 ) { - ret =get_errno ((long )host_addr); -break ; - } - raddr =h2g ((unsigned long )host_addr); -/* find out the length of the shared memory segment */ - - ret =get_errno (shmctl (first,IPC_STAT , &shm_info)); -if (is_error (ret)) { -/* can't get length, bail out */ -shmdt (host_addr); -break ; - } -page_set_flags (raddr, raddr + shm_info.shm_segsz, -PAGE_VALID |PAGE_READ | - ((second &SHM_RDONLY )?0 :PAGE_WRITE )); -for (i =0 ; i <N_SHM_REGIONS ; ++i) { -if (shm_regions[i].start ==0 ) { - shm_regions[i].start = raddr; - shm_regions[i].size = shm_info.shm_segsz; -break ; - } - } + raddr =do_shmat (first, ptr, second); +if (is_error (raddr)) +return get_errno (raddr);if (put_user_ual (raddr, third))return -TARGET_EFAULT ; - ret =0 ; +break ; + } +case 1 : + ret = -TARGET_EINVAL ; +break ; }break ;case IPCOP_shmdt: -for (i =0 ; i <N_SHM_REGIONS ; ++i) { -if (shm_regions[i].start == ptr) { - shm_regions[i].start =0 ; -page_set_flags (ptr, shm_regions[i].size,0 ); -break ; - } - } - ret =get_errno (shmdt ((void *)g2h (ptr))); + ret =do_shmdt (ptr);break ;case IPCOP_shmget:
@@ -2268,18 +2458,9 @@ static abi_long do_ipc(unsigned int call, int first,/* IPC_* and SHM_* command values are the same on all linux platforms */ case IPCOP_shmctl: -switch (second) { -case IPC_RMID : -case SHM_LOCK : -case SHM_UNLOCK : - ret =get_errno (shmctl (first, second,NULL )); -break ; -default : - goto unimplemented; - } + ret =do_shmctl (first, second, third);break ;default : - unimplemented:gemu_log ("Unsupported ipc call: %d (version %d)\n" , call, version); ret = -TARGET_ENOSYS ;break ;
@@ -5043,6 +5224,26 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1, ret =do_msgsnd (arg1, arg2, arg3, arg4);break ;#endif +#ifdef TARGET_NR_shmget +case TARGET_NR_shmget: + ret =get_errno (shmget (arg1, arg2, arg3)); +break ; +#endif +#ifdef TARGET_NR_shmctl +case TARGET_NR_shmctl: + ret =do_shmctl (arg1, arg2, arg3); +break ; +#endif +#ifdef TARGET_NR_shmat +case TARGET_NR_shmat: + ret =do_shmat (arg1, arg2, arg3); +break ; +#endif +#ifdef TARGET_NR_shmdt +case TARGET_NR_shmdt: + ret =do_shmdt (arg1); +break ; +#endif case TARGET_NR_fsync: ret =get_errno (fsync (arg1));break ;
Signature · 1 line
1.6.2.1
PATCH 4/10 fix IPCOP_sem* and implement sem*
In reply to [email protected]From: Riku Voipio <[email protected]>
From: Kirill A. Shutemov <[email protected]>
Fix and cleanup IPCOP_sem* ipc calls handling and
implement sem* syscalls.
Uglify whitespace so that diff gets smaller and easier to review - Riku
--- linux-user/syscall.c | 286 +++++++++++++++++++++++++++++++++----------------- 1 files changed, 188 insertions(+), 98 deletions(-)
linux-user/syscall.c +188 -98
@@ -1733,7 +1733,8 @@ static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,if (!lock_user_struct (VERIFY_READ , target_sd, target_addr,1 ))return -TARGET_EFAULT ; -target_to_host_ipc_perm (&(host_sd->sem_perm),target_addr); +if (target_to_host_ipc_perm (&(host_sd->sem_perm),target_addr)) +return -TARGET_EFAULT ; host_sd->sem_nsems =tswapl (target_sd->sem_nsems); host_sd->sem_otime =tswapl (target_sd->sem_otime); host_sd->sem_ctime =tswapl (target_sd->sem_ctime);
@@ -1748,7 +1749,8 @@ static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,if (!lock_user_struct (VERIFY_WRITE , target_sd, target_addr,0 ))return -TARGET_EFAULT ; -host_to_target_ipc_perm (target_addr,&(host_sd->sem_perm)); +if (host_to_target_ipc_perm (target_addr,&(host_sd->sem_perm))) +return -TARGET_EFAULT ;; target_sd->sem_nsems =tswapl (host_sd->sem_nsems); target_sd->sem_otime =tswapl (host_sd->sem_otime); target_sd->sem_ctime =tswapl (host_sd->sem_ctime);
@@ -1756,135 +1758,214 @@ static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,return 0 ; } +struct target_seminfo { +int semmap; +int semmni; +int semmns; +int semmnu; +int semmsl; +int semopm; +int semume; +int semusz; +int semvmx; +int semaem; +}; + +static inline abi_long host_to_target_seminfo (abi_ulong target_addr, +struct seminfo *host_seminfo) +{ +struct target_seminfo *target_seminfo; +if (!lock_user_struct (VERIFY_WRITE , target_seminfo, target_addr,0 )) +return -TARGET_EFAULT ; +__put_user (host_seminfo->semmap, &target_seminfo->semmap); +__put_user (host_seminfo->semmni, &target_seminfo->semmni); +__put_user (host_seminfo->semmns, &target_seminfo->semmns); +__put_user (host_seminfo->semmnu, &target_seminfo->semmnu); +__put_user (host_seminfo->semmsl, &target_seminfo->semmsl); +__put_user (host_seminfo->semopm, &target_seminfo->semopm); +__put_user (host_seminfo->semume, &target_seminfo->semume); +__put_user (host_seminfo->semusz, &target_seminfo->semusz); +__put_user (host_seminfo->semvmx, &target_seminfo->semvmx); +__put_user (host_seminfo->semaem, &target_seminfo->semaem); +unlock_user_struct (target_seminfo, target_addr,1 ); +return 0 ; +} +union semun {int val;struct semid_ds *buf;unsigned short *array; +struct seminfo *__buf; };union target_semun {int val; -abi_long buf; -unsigned short int *array; +abi_ulong buf; +abi_ulong array; +abi_ulong __buf; }; -static inline abi_long target_to_host_semun (int cmd, -union semun *host_su, -abi_ulong target_addr, -struct semid_ds *ds) +static inline abi_long target_to_host_semarray (int semid,unsigned short **host_array, +abi_ulong target_addr) { -union target_semun *target_su; +int nsems; +unsigned short *array; +union semun semun; +struct semid_ds semid_ds; +int i, ret; -switch ( cmd ) { -case IPC_STAT : -case IPC_SET : -if (!lock_user_struct (VERIFY_READ , target_su, target_addr,1 )) -return -TARGET_EFAULT ; -target_to_host_semid_ds (ds,target_su->buf); - host_su->buf = ds; -unlock_user_struct (target_su, target_addr,0 ); -break ; -case GETVAL : -case SETVAL : -if (!lock_user_struct (VERIFY_READ , target_su, target_addr,1 )) -return -TARGET_EFAULT ; - host_su->val =tswapl (target_su->val); -unlock_user_struct (target_su, target_addr,0 ); -break ; -case GETALL : -case SETALL : -if (!lock_user_struct (VERIFY_READ , target_su, target_addr,1 )) -return -TARGET_EFAULT ; - *host_su->array =tswap16 (*target_su->array); -unlock_user_struct (target_su, target_addr,0 ); -break ; -default : -gemu_log ("semun operation not fully supported: %d\n" , (int )cmd); + semun.buf = &semid_ds; + + ret =semctl (semid,0 ,IPC_STAT , semun); +if (ret ==-1 ) +return get_errno (ret); + + nsems = semid_ds.sem_nsems; + + *host_array =malloc (nsems*sizeof (unsigned short )); + array =lock_user (VERIFY_READ , target_addr, + nsems*sizeof (unsigned short ),1 ); +if (!array) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsems; i++) { +__get_user ((*host_array)[i], &array[i]); } +unlock_user (array, target_addr,0 ); +return 0 ; } -static inline abi_long host_to_target_semun (int cmd, -abi_ulong target_addr, -union semun *host_su, -struct semid_ds *ds) +static inline abi_long host_to_target_semarray (int semid,abi_ulong target_addr, +unsigned short **host_array) { -union target_semun *target_su; +int nsems; +unsigned short *array; +union semun semun; +struct semid_ds semid_ds; +int i, ret; -switch ( cmd ) { -case IPC_STAT : -case IPC_SET : -if (lock_user_struct (VERIFY_WRITE , target_su, target_addr,0 )) -return -TARGET_EFAULT ; -host_to_target_semid_ds (target_su->buf,ds); -unlock_user_struct (target_su, target_addr,1 ); -break ; -case GETVAL : -case SETVAL : -if (lock_user_struct (VERIFY_WRITE , target_su, target_addr,0 )) -return -TARGET_EFAULT ; - target_su->val =tswapl (host_su->val); -unlock_user_struct (target_su, target_addr,1 ); -break ; -case GETALL : -case SETALL : -if (lock_user_struct (VERIFY_WRITE , target_su, target_addr,0 )) -return -TARGET_EFAULT ; - *target_su->array =tswap16 (*host_su->array); -unlock_user_struct (target_su, target_addr,1 ); -break ; -default : -gemu_log ("semun operation not fully supported: %d\n" , (int )cmd); + semun.buf = &semid_ds; + + ret =semctl (semid,0 ,IPC_STAT , semun); +if (ret ==-1 ) +return get_errno (ret); + + nsems = semid_ds.sem_nsems; + + array =lock_user (VERIFY_WRITE , target_addr, + nsems*sizeof (unsigned short ),0 ); +if (!array) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsems; i++) { +__put_user ((*host_array)[i], &array[i]); } +free (*host_array); +unlock_user (array, target_addr,1 ); +return 0 ; } -static inline abi_long do_semctl (int first,int second,int third, -abi_long ptr) +static inline abi_long do_semctl (int semid,int semnum,int cmd, +union target_semun target_su) {union semun arg;struct semid_ds dsarg; -int cmd = third&0xff ; -abi_long ret =0 ; +unsigned short *array; +struct seminfo seminfo; +abi_long ret = -TARGET_EINVAL ; +abi_long err; + cmd &=0xff ;switch ( cmd ) {case GETVAL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); -break ;case SETVAL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); + arg.val =tswapl (target_su.val); + ret =get_errno (semctl (semid, semnum, cmd, arg)); + target_su.val =tswapl (arg.val);break ;case GETALL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); -break ;case SETALL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); + err =target_to_host_semarray (semid, &array, target_su.array); +if (err) +return err; + arg.array = array; + ret =get_errno (semctl (semid, semnum, cmd, arg)); + err =host_to_target_semarray (semid, target_su.array, &array); +if (err) +return err;break ;case IPC_STAT : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); -break ;case IPC_SET : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); +case SEM_STAT : + err =target_to_host_semid_ds (&dsarg, target_su.buf); +if (err) +return err; + arg.buf = &dsarg; + ret =get_errno (semctl (semid, semnum, cmd, arg)); + err =host_to_target_semid_ds (target_su.buf, &dsarg); +if (err) +return err; +break ; +case IPC_INFO : +case SEM_INFO : + arg.__buf = &seminfo; + ret =get_errno (semctl (semid, semnum, cmd, arg)); + err =host_to_target_seminfo (target_su.__buf, &seminfo); +if (err) +return err; +break ; +case IPC_RMID : +case GETPID : +case GETNCNT : +case GETZCNT : + ret =get_errno (semctl (semid, semnum, cmd,NULL ));break ; -default : - ret =get_errno (semctl (first, second, cmd, arg)); }return ret; } +struct target_sembuf { +unsigned short sem_num; +short sem_op; +short sem_flg; +}; + +static inline abi_long target_to_host_sembuf (struct sembuf *host_sembuf, +abi_ulong target_addr, +unsigned nsops) +{ +struct target_sembuf *target_sembuf; +int i; + + target_sembuf =lock_user (VERIFY_READ , target_addr, + nsops*sizeof (struct target_sembuf ),1 ); +if (!target_sembuf) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsops; i++) { +__put_user (target_sembuf[i].sem_num, &host_sembuf[i].sem_num); +__put_user (target_sembuf[i].sem_op, &host_sembuf[i].sem_op); +__put_user (target_sembuf[i].sem_flg, &host_sembuf[i].sem_flg); + } + +unlock_user (target_sembuf, target_addr,0 ); + +return 0 ; +} + +static inline abi_long do_semop (int semid,abi_long ptr,unsigned nsops) +{ +struct sembuf sops[nsops]; + +if (target_to_host_sembuf (sops, ptr, nsops)) +return -TARGET_EFAULT ; + +return semop (semid, sops, nsops); +} +struct target_msqid_ds {struct target_ipc_perm msg_perm;
@@ -2088,7 +2169,7 @@ static abi_long do_ipc(unsigned int call, int first,switch (call) {case IPCOP_semop: - ret =get_errno (semop (first,(struct sembuf *)g2h (ptr), second)); + ret =do_semop (first, ptr, second);break ;case IPCOP_semget:
@@ -2096,12 +2177,7 @@ static abi_long do_ipc(unsigned int call, int first,break ;case IPCOP_semctl: - ret =do_semctl (first, second, third, ptr); -break ; - -case IPCOP_semtimedop: -gemu_log ("Unsupported ipc call: %d (version %d)\n" , call, version); - ret = -TARGET_ENOSYS ; + ret =do_semctl (first, second, third, (union target_semun )(abi_ulong ) ptr);break ;case IPCOP_msgget:
@@ -4932,7 +5008,21 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1, ret =do_ipc (arg1, arg2, arg3, arg4, arg5, arg6);break ;#endif - +#ifdef TARGET_NR_semget +case TARGET_NR_semget: + ret =get_errno (semget (arg1, arg2, arg3)); +break ; +#endif +#ifdef TARGET_NR_semop +case TARGET_NR_semop: + ret =get_errno (do_semop (arg1, arg2, arg3)); +break ; +#endif +#ifdef TARGET_NR_semctl +case TARGET_NR_semctl: + ret =do_semctl (arg1, arg2, arg3, (union target_semun )(abi_ulong )arg4); +break ; +#endif #ifdef TARGET_NR_msgctlcase TARGET_NR_msgctl: ret =do_msgctl (arg1, arg2, arg3);
Signature · 1 line
1.6.2.1
Re: [Qemu-devel] [PATCH 04/10] fix IPCOP_sem* and implement sem*
[email protected] writes:
Hi,
Quoted 6 lines
linux-user/syscall.c +2
-2-static inline abi_long do_semctl (int first,int second,int third, -abi_long ptr) +static inline abi_long do_semctl (int semid,int semnum,int cmd, +union target_semun target_su) {union semun arg;
linux-user/syscall.c static inline abi_long host_to_target_semid_ds(abi_ulong target_addr, · line 1881
Quoted 10 lines
linux-user/syscall.c +5
-2struct semid_ds dsarg; -int cmd = third&0xff ; -abi_long ret =0 ; +unsigned short *array; +struct seminfo seminfo; +abi_long ret = -TARGET_EINVAL ; +abi_long err; + cmd &=0xff ;switch ( cmd ) {
I'm wondering if it's a good way of handling the IPC_64 flag. afaik this flag is set to indicate that we're using newer ipc version, so if it's set, the code may use things like 32bit uids.
Taking this into account, is it possible that falling back to the old *ctl versions is breaking some applications ?
Thanks,
Arnaud
Re: [Qemu-devel] [PATCH 04/10] fix IPCOP_sem* and implement sem*
Quoted 19 lines · Arnaud Patard
[email protected] writes:
Hi,
Quoted 15 lines
linux-user/syscall.c +7
-4-static inline abi_long do_semctl (int first,int second,int third, -abi_long ptr) +static inline abi_long do_semctl (int semid,int semnum,int cmd, +union target_semun target_su) {union semun arg;struct semid_ds dsarg; -int cmd = third&0xff ; -abi_long ret =0 ; +unsigned short *array; +struct seminfo seminfo; +abi_long ret = -TARGET_EINVAL ; +abi_long err; + cmd &=0xff ;
Quoted 7 lines
Quoted 1 line
switch( cmd ) {I'm wondering if it's a good way of handling the
IPC_64flag. afaik this flag is set to indicate that we're using newer ipc version, so if it's set, the code may use things like 32bit uids.
Taking this into account, is it possible that falling back to the old *ctl versions is breaking some applications ?
As far as I see the patch doesn't change qemu's behaviour in this respect? I didn't see any failures in ltp testing with amd64/i386 hosts and arm arm target. Would some other target/host combination be more suspectible from errors of this behaviour? when running qemu-arm under i386, glibc appears to add the IPC_64 flag when qemu is calling sem* functions.
Signature · 1 line
"rm -rf" only sounds scary if you don't have backups
Re: [Qemu-devel] [PATCH 04/10] fix IPCOP_sem* and implement sem*
Quoted 28 lines · Riku Voipio
Quoted 19 lines · Arnaud Patard
[email protected] writes:
Hi,
Quoted 15 lines
linux-user/syscall.c +7
-4-static inline abi_long do_semctl (int first,int second,int third, -abi_long ptr) +static inline abi_long do_semctl (int semid,int semnum,int cmd, +union target_semun target_su) {union semun arg;struct semid_ds dsarg; -int cmd = third&0xff ; -abi_long ret =0 ; +unsigned short *array; +struct seminfo seminfo; +abi_long ret = -TARGET_EINVAL ; +abi_long err; + cmd &=0xff ;Quoted 7 lines
Quoted 1 line
switch( cmd ) {I'm wondering if it's a good way of handling the
IPC_64flag. afaik this flag is set to indicate that we're using newer ipc version, so if it's set, the code may use things like 32bit uids.
Taking this into account, is it possible that falling back to the old *ctl versions is breaking some applications ?
Quoted 1 line
As far as I see the patch doesn't change qemu's behaviour in this respect?
well, in case of semctl, it was broken so it does change the behaviour. In case of shmctl, you're right it's changing nothing
Quoted 4 lines
I didn't see any failures in ltp testing with amd64/i386 hosts and arm arm target. Would some other target/host combination be more suspectible from errors of this behaviour? when running qemu-arm under i386, glibc appears to add the
IPC_64flag when qemu is calling sem* functions.
Well, it was an open question. I've seen the semctl breakage and then your patch. When looking at it, I've noticed that it might break something but I've no idea if it's breaking something in practice. That's why I've asked.
Arnaud
Re: [Qemu-devel] [PATCH 04/10] fix IPCOP_sem* and implement sem*
In reply to [email protected]Quoted 313 lines · On Sun, Apr 05, 2009 at 11:59:20PM +0300, [email protected] wrote:
From: Riku Voipio <[email protected]>
From: Kirill A. Shutemov <[email protected]>
Fix and cleanup IPCOP_sem* ipc calls handling and
implement sem* syscalls.Uglify whitespace so that diff gets smaller and easier to review - Riku
Signed-off-by Riku Voipio <[email protected]>--- linux-user/syscall.c | 286 +++++++++++++++++++++++++++++++++----------------- 1 files changed, 188 insertions(+), 98 deletions(-)linux-user/syscall.c +145
-90@@ -1733,7 +1733,8 @@ static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,if (!lock_user_struct (VERIFY_READ , target_sd, target_addr,1 ))return -TARGET_EFAULT ; -target_to_host_ipc_perm (&(host_sd->sem_perm),target_addr); +if (target_to_host_ipc_perm (&(host_sd->sem_perm),target_addr)) +return -TARGET_EFAULT ; host_sd->sem_nsems =tswapl (target_sd->sem_nsems); host_sd->sem_otime =tswapl (target_sd->sem_otime); host_sd->sem_ctime =tswapl (target_sd->sem_ctime);@@ -1748,7 +1749,8 @@ static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,if (!lock_user_struct (VERIFY_WRITE , target_sd, target_addr,0 ))return -TARGET_EFAULT ; -host_to_target_ipc_perm (target_addr,&(host_sd->sem_perm)); +if (host_to_target_ipc_perm (target_addr,&(host_sd->sem_perm))) +return -TARGET_EFAULT ;; target_sd->sem_nsems =tswapl (host_sd->sem_nsems); target_sd->sem_otime =tswapl (host_sd->sem_otime); target_sd->sem_ctime =tswapl (host_sd->sem_ctime);@@ -1756,135 +1758,214 @@ static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,return 0 ; } +struct target_seminfo { +int semmap; +int semmni; +int semmns; +int semmnu; +int semmsl; +int semopm; +int semume; +int semusz; +int semvmx; +int semaem; +}; + +static inline abi_long host_to_target_seminfo (abi_ulong target_addr, +struct seminfo *host_seminfo) +{ +struct target_seminfo *target_seminfo; +if (!lock_user_struct (VERIFY_WRITE , target_seminfo, target_addr,0 )) +return -TARGET_EFAULT ; +__put_user (host_seminfo->semmap, &target_seminfo->semmap); +__put_user (host_seminfo->semmni, &target_seminfo->semmni); +__put_user (host_seminfo->semmns, &target_seminfo->semmns); +__put_user (host_seminfo->semmnu, &target_seminfo->semmnu); +__put_user (host_seminfo->semmsl, &target_seminfo->semmsl); +__put_user (host_seminfo->semopm, &target_seminfo->semopm); +__put_user (host_seminfo->semume, &target_seminfo->semume); +__put_user (host_seminfo->semusz, &target_seminfo->semusz); +__put_user (host_seminfo->semvmx, &target_seminfo->semvmx); +__put_user (host_seminfo->semaem, &target_seminfo->semaem); +unlock_user_struct (target_seminfo, target_addr,1 ); +return 0 ; +} +union semun {int val;struct semid_ds *buf;unsigned short *array; +struct seminfo *__buf; };union target_semun {int val; -abi_long buf; -unsigned short int *array; +abi_ulong buf; +abi_ulong array; +abi_ulong __buf; }; -static inline abi_long target_to_host_semun (int cmd, -union semun *host_su, -abi_ulong target_addr, -struct semid_ds *ds) +static inline abi_long target_to_host_semarray (int semid,unsigned short **host_array, +abi_ulong target_addr) { -union target_semun *target_su; +int nsems; +unsigned short *array; +union semun semun; +struct semid_ds semid_ds; +int i, ret; -switch ( cmd ) { -case IPC_STAT : -case IPC_SET : -if (!lock_user_struct (VERIFY_READ , target_su, target_addr,1 )) -return -TARGET_EFAULT ; -target_to_host_semid_ds (ds,target_su->buf); - host_su->buf = ds; -unlock_user_struct (target_su, target_addr,0 ); -break ; -case GETVAL : -case SETVAL : -if (!lock_user_struct (VERIFY_READ , target_su, target_addr,1 )) -return -TARGET_EFAULT ; - host_su->val =tswapl (target_su->val); -unlock_user_struct (target_su, target_addr,0 ); -break ; -case GETALL : -case SETALL : -if (!lock_user_struct (VERIFY_READ , target_su, target_addr,1 )) -return -TARGET_EFAULT ; - *host_su->array =tswap16 (*target_su->array); -unlock_user_struct (target_su, target_addr,0 ); -break ; -default : -gemu_log ("semun operation not fully supported: %d\n" , (int )cmd); + semun.buf = &semid_ds; + + ret =semctl (semid,0 ,IPC_STAT , semun); +if (ret ==-1 ) +return get_errno (ret); + + nsems = semid_ds.sem_nsems; + + *host_array =malloc (nsems*sizeof (unsigned short )); + array =lock_user (VERIFY_READ , target_addr, + nsems*sizeof (unsigned short ),1 ); +if (!array) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsems; i++) { +__get_user ((*host_array)[i], &array[i]); } +unlock_user (array, target_addr,0 ); +return 0 ; } -static inline abi_long host_to_target_semun (int cmd, -abi_ulong target_addr, -union semun *host_su, -struct semid_ds *ds) +static inline abi_long host_to_target_semarray (int semid,abi_ulong target_addr, +unsigned short **host_array) { -union target_semun *target_su; +int nsems; +unsigned short *array; +union semun semun; +struct semid_ds semid_ds; +int i, ret; -switch ( cmd ) { -case IPC_STAT : -case IPC_SET : -if (lock_user_struct (VERIFY_WRITE , target_su, target_addr,0 )) -return -TARGET_EFAULT ; -host_to_target_semid_ds (target_su->buf,ds); -unlock_user_struct (target_su, target_addr,1 ); -break ; -case GETVAL : -case SETVAL : -if (lock_user_struct (VERIFY_WRITE , target_su, target_addr,0 )) -return -TARGET_EFAULT ; - target_su->val =tswapl (host_su->val); -unlock_user_struct (target_su, target_addr,1 ); -break ; -case GETALL : -case SETALL : -if (lock_user_struct (VERIFY_WRITE , target_su, target_addr,0 )) -return -TARGET_EFAULT ; - *target_su->array =tswap16 (*host_su->array); -unlock_user_struct (target_su, target_addr,1 ); -break ; -default : -gemu_log ("semun operation not fully supported: %d\n" , (int )cmd); + semun.buf = &semid_ds; + + ret =semctl (semid,0 ,IPC_STAT , semun); +if (ret ==-1 ) +return get_errno (ret); + + nsems = semid_ds.sem_nsems; + + array =lock_user (VERIFY_WRITE , target_addr, + nsems*sizeof (unsigned short ),0 ); +if (!array) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsems; i++) { +__put_user ((*host_array)[i], &array[i]); } +free (*host_array); +unlock_user (array, target_addr,1 ); +return 0 ; } -static inline abi_long do_semctl (int first,int second,int third, -abi_long ptr) +static inline abi_long do_semctl (int semid,int semnum,int cmd, +union target_semun target_su) {union semun arg;struct semid_ds dsarg; -int cmd = third&0xff ; -abi_long ret =0 ; +unsigned short *array; +struct seminfo seminfo; +abi_long ret = -TARGET_EINVAL ; +abi_long err; + cmd &=0xff ;switch ( cmd ) {case GETVAL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); -break ;case SETVAL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); + arg.val =tswapl (target_su.val); + ret =get_errno (semctl (semid, semnum, cmd, arg)); + target_su.val =tswapl (arg.val);break ;case GETALL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); -break ;case SETALL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); + err =target_to_host_semarray (semid, &array, target_su.array); +if (err) +return err; + arg.array = array; + ret =get_errno (semctl (semid, semnum, cmd, arg)); + err =host_to_target_semarray (semid, target_su.array, &array); +if (err) +return err;break ;case IPC_STAT : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); -break ;case IPC_SET : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); +case SEM_STAT : + err =target_to_host_semid_ds (&dsarg, target_su.buf); +if (err) +return err; + arg.buf = &dsarg; + ret =get_errno (semctl (semid, semnum, cmd, arg)); + err =host_to_target_semid_ds (target_su.buf, &dsarg); +if (err) +return err; +break ; +case IPC_INFO : +case SEM_INFO : + arg.__buf = &seminfo; + ret =get_errno (semctl (semid, semnum, cmd, arg)); + err =host_to_target_seminfo (target_su.__buf, &seminfo); +if (err) +return err; +break ; +case IPC_RMID : +case GETPID : +case GETNCNT : +case GETZCNT : + ret =get_errno (semctl (semid, semnum, cmd,NULL ));break ; -default : - ret =get_errno (semctl (first, second, cmd, arg)); }return ret; } +struct target_sembuf { +unsigned short sem_num; +short sem_op; +short sem_flg; +}; + +static inline abi_long target_to_host_sembuf (struct sembuf *host_sembuf, +abi_ulong target_addr, +unsigned nsops) +{ +struct target_sembuf *target_sembuf; +int i; +
linux-user/syscall.c static inline abi_long host_to_target_semid_ds(abi_ulong target_addr, · line 1952
Quoted 10 lines
linux-user/syscall.c +10
-0+ target_sembuf =lock_user (VERIFY_READ , target_addr, + nsops*sizeof (struct target_sembuf ),1 ); +if (!target_sembuf) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsops; i++) { +__put_user (target_sembuf[i].sem_num, &host_sembuf[i].sem_num); +__put_user (target_sembuf[i].sem_op, &host_sembuf[i].sem_op); +__put_user (target_sembuf[i].sem_flg, &host_sembuf[i].sem_flg); + }
I don't follow fully the subtle difference between __put_user() and __get_user,() but given lock_user is called with VERIFY_READ, I think __get_user() should be used instead.
Quoted 70 lines
linux-user/syscall.c +32
-8+unlock_user (target_sembuf, target_addr,0 ); + +return 0 ; +} + +static inline abi_long do_semop (int semid,abi_long ptr,unsigned nsops) +{ +struct sembuf sops[nsops]; + +if (target_to_host_sembuf (sops, ptr, nsops)) +return -TARGET_EFAULT ; + +return semop (semid, sops, nsops); +} +struct target_msqid_ds {struct target_ipc_perm msg_perm;@@ -2088,7 +2169,7 @@ static abi_long do_ipc(unsigned int call, int first,switch (call) {case IPCOP_semop: - ret =get_errno (semop (first,(struct sembuf *)g2h (ptr), second)); + ret =do_semop (first, ptr, second);break ;case IPCOP_semget:@@ -2096,12 +2177,7 @@ static abi_long do_ipc(unsigned int call, int first,break ;case IPCOP_semctl: - ret =do_semctl (first, second, third, ptr); -break ; - -case IPCOP_semtimedop: -gemu_log ("Unsupported ipc call: %d (version %d)\n" , call, version); - ret = -TARGET_ENOSYS ; + ret =do_semctl (first, second, third, (union target_semun )(abi_ulong ) ptr);break ;case IPCOP_msgget:@@ -4932,7 +5008,21 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1, ret =do_ipc (arg1, arg2, arg3, arg4, arg5, arg6);break ;#endif - +#ifdef TARGET_NR_semget +case TARGET_NR_semget: + ret =get_errno (semget (arg1, arg2, arg3)); +break ; +#endif +#ifdef TARGET_NR_semop +case TARGET_NR_semop: + ret =get_errno (do_semop (arg1, arg2, arg3)); +break ; +#endif +#ifdef TARGET_NR_semctl +case TARGET_NR_semctl: + ret =do_semctl (arg1, arg2, arg3, (union target_semun )(abi_ulong )arg4); +break ; +#endif #ifdef TARGET_NR_msgctlcase TARGET_NR_msgctl: ret =do_msgctl (arg1, arg2, arg3);Signature · 1 line
1.6.2.1
Signature · 2 lines
Aurelien Jarno GPG: 1024D/F1BCDB73 [email protected] http://www.aurel32.net
Re: [Qemu-devel] [PATCH 04/10] fix IPCOP_sem* and implement sem*
Quoted 19 lines · Aurelien Jarno
Quoted 19 lines
(quoted diff) +19
-0+struct target_sembuf { + unsigned short sem_num; + short sem_op; + short sem_flg; +}; + +static inline abi_long target_to_host_sembuf(struct sembuf *host_sembuf, + abi_ulong target_addr, + unsigned nsops) +{ + struct target_sembuf *target_sembuf; + int i; + + target_sembuf = lock_user(VERIFY_READ, target_addr, + nsops*sizeof(struct target_sembuf), 1); + if (!target_sembuf) + return -TARGET_EFAULT; + + for(i=0; i<nsops; i++) {
Quoted 8 lines
Review
Quoted 4 lines
(quoted diff) +4
-0+ __put_user(target_sembuf[i].sem_num, &host_sembuf[i].sem_num); + __put_user(target_sembuf[i].sem_op, &host_sembuf[i].sem_op); + __put_user(target_sembuf[i].sem_flg, &host_sembuf[i].sem_flg); + }I don't follow fully the subtle difference between
__put_user()and __get_user,() but givenlock_useris called withVERIFY_READ, I think__get_user()should be used instead.
Yes.. since the target and host args are swapped, it still works like __get_user. Corrected version attached.
(This error appears also once in the shm* patch too)
Quoted 1 line
From
32b512d9b521d2b146658f932b9c3553cd3ec1cdMon Sep 17 00:00:00 2001
From: Riku Voipio <[email protected]>
Date: Fri, 3 Apr 2009 00:28:14 +0300
Subject: [PATCH] [v2] fix IPCOP_sem* and implement sem*
From: Kirill A. Shutemov <[email protected]>
Fix and cleanup IPCOP_sem* ipc calls handling and
implement sem* syscalls.
Riku:
1) Uglify whitespace so that diff gets smaller and easier to review
2) use __get_user in target_to_host_sembuf
--- linux-user/syscall.c | 286 +++++++++++++++++++++++++++++++++----------------- 1 files changed, 188 insertions(+), 98 deletions(-)
linux-user/syscall.c +188 -98
@@ -2005,7 +2005,8 @@ static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,if (!lock_user_struct (VERIFY_READ , target_sd, target_addr,1 ))return -TARGET_EFAULT ; -target_to_host_ipc_perm (&(host_sd->sem_perm),target_addr); +if (target_to_host_ipc_perm (&(host_sd->sem_perm),target_addr)) +return -TARGET_EFAULT ; host_sd->sem_nsems =tswapl (target_sd->sem_nsems); host_sd->sem_otime =tswapl (target_sd->sem_otime); host_sd->sem_ctime =tswapl (target_sd->sem_ctime);
@@ -2020,7 +2021,8 @@ static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,if (!lock_user_struct (VERIFY_WRITE , target_sd, target_addr,0 ))return -TARGET_EFAULT ; -host_to_target_ipc_perm (target_addr,&(host_sd->sem_perm)); +if (host_to_target_ipc_perm (target_addr,&(host_sd->sem_perm))) +return -TARGET_EFAULT ;; target_sd->sem_nsems =tswapl (host_sd->sem_nsems); target_sd->sem_otime =tswapl (host_sd->sem_otime); target_sd->sem_ctime =tswapl (host_sd->sem_ctime);
@@ -2028,135 +2030,214 @@ static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,return 0 ; } +struct target_seminfo { +int semmap; +int semmni; +int semmns; +int semmnu; +int semmsl; +int semopm; +int semume; +int semusz; +int semvmx; +int semaem; +}; + +static inline abi_long host_to_target_seminfo (abi_ulong target_addr, +struct seminfo *host_seminfo) +{ +struct target_seminfo *target_seminfo; +if (!lock_user_struct (VERIFY_WRITE , target_seminfo, target_addr,0 )) +return -TARGET_EFAULT ; +__put_user (host_seminfo->semmap, &target_seminfo->semmap); +__put_user (host_seminfo->semmni, &target_seminfo->semmni); +__put_user (host_seminfo->semmns, &target_seminfo->semmns); +__put_user (host_seminfo->semmnu, &target_seminfo->semmnu); +__put_user (host_seminfo->semmsl, &target_seminfo->semmsl); +__put_user (host_seminfo->semopm, &target_seminfo->semopm); +__put_user (host_seminfo->semume, &target_seminfo->semume); +__put_user (host_seminfo->semusz, &target_seminfo->semusz); +__put_user (host_seminfo->semvmx, &target_seminfo->semvmx); +__put_user (host_seminfo->semaem, &target_seminfo->semaem); +unlock_user_struct (target_seminfo, target_addr,1 ); +return 0 ; +} +union semun {int val;struct semid_ds *buf;unsigned short *array; +struct seminfo *__buf; };union target_semun {int val; -abi_long buf; -unsigned short int *array; +abi_ulong buf; +abi_ulong array; +abi_ulong __buf; }; -static inline abi_long target_to_host_semun (int cmd, -union semun *host_su, -abi_ulong target_addr, -struct semid_ds *ds) +static inline abi_long target_to_host_semarray (int semid,unsigned short **host_array, +abi_ulong target_addr) { -union target_semun *target_su; +int nsems; +unsigned short *array; +union semun semun; +struct semid_ds semid_ds; +int i, ret; -switch ( cmd ) { -case IPC_STAT : -case IPC_SET : -if (!lock_user_struct (VERIFY_READ , target_su, target_addr,1 )) -return -TARGET_EFAULT ; -target_to_host_semid_ds (ds,target_su->buf); - host_su->buf = ds; -unlock_user_struct (target_su, target_addr,0 ); -break ; -case GETVAL : -case SETVAL : -if (!lock_user_struct (VERIFY_READ , target_su, target_addr,1 )) -return -TARGET_EFAULT ; - host_su->val =tswapl (target_su->val); -unlock_user_struct (target_su, target_addr,0 ); -break ; -case GETALL : -case SETALL : -if (!lock_user_struct (VERIFY_READ , target_su, target_addr,1 )) -return -TARGET_EFAULT ; - *host_su->array =tswap16 (*target_su->array); -unlock_user_struct (target_su, target_addr,0 ); -break ; -default : -gemu_log ("semun operation not fully supported: %d\n" , (int )cmd); + semun.buf = &semid_ds; + + ret =semctl (semid,0 ,IPC_STAT , semun); +if (ret ==-1 ) +return get_errno (ret); + + nsems = semid_ds.sem_nsems; + + *host_array =malloc (nsems*sizeof (unsigned short )); + array =lock_user (VERIFY_READ , target_addr, + nsems*sizeof (unsigned short ),1 ); +if (!array) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsems; i++) { +__get_user ((*host_array)[i], &array[i]); } +unlock_user (array, target_addr,0 ); +return 0 ; } -static inline abi_long host_to_target_semun (int cmd, -abi_ulong target_addr, -union semun *host_su, -struct semid_ds *ds) +static inline abi_long host_to_target_semarray (int semid,abi_ulong target_addr, +unsigned short **host_array) { -union target_semun *target_su; +int nsems; +unsigned short *array; +union semun semun; +struct semid_ds semid_ds; +int i, ret; -switch ( cmd ) { -case IPC_STAT : -case IPC_SET : -if (lock_user_struct (VERIFY_WRITE , target_su, target_addr,0 )) -return -TARGET_EFAULT ; -host_to_target_semid_ds (target_su->buf,ds); -unlock_user_struct (target_su, target_addr,1 ); -break ; -case GETVAL : -case SETVAL : -if (lock_user_struct (VERIFY_WRITE , target_su, target_addr,0 )) -return -TARGET_EFAULT ; - target_su->val =tswapl (host_su->val); -unlock_user_struct (target_su, target_addr,1 ); -break ; -case GETALL : -case SETALL : -if (lock_user_struct (VERIFY_WRITE , target_su, target_addr,0 )) -return -TARGET_EFAULT ; - *target_su->array =tswap16 (*host_su->array); -unlock_user_struct (target_su, target_addr,1 ); -break ; -default : -gemu_log ("semun operation not fully supported: %d\n" , (int )cmd); + semun.buf = &semid_ds; + + ret =semctl (semid,0 ,IPC_STAT , semun); +if (ret ==-1 ) +return get_errno (ret); + + nsems = semid_ds.sem_nsems; + + array =lock_user (VERIFY_WRITE , target_addr, + nsems*sizeof (unsigned short ),0 ); +if (!array) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsems; i++) { +__put_user ((*host_array)[i], &array[i]); } +free (*host_array); +unlock_user (array, target_addr,1 ); +return 0 ; } -static inline abi_long do_semctl (int first,int second,int third, -abi_long ptr) +static inline abi_long do_semctl (int semid,int semnum,int cmd, +union target_semun target_su) {union semun arg;struct semid_ds dsarg; -int cmd = third&0xff ; -abi_long ret =0 ; +unsigned short *array; +struct seminfo seminfo; +abi_long ret = -TARGET_EINVAL ; +abi_long err; + cmd &=0xff ;switch ( cmd ) {case GETVAL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); -break ;case SETVAL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); + arg.val =tswapl (target_su.val); + ret =get_errno (semctl (semid, semnum, cmd, arg)); + target_su.val =tswapl (arg.val);break ;case GETALL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); -break ;case SETALL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); + err =target_to_host_semarray (semid, &array, target_su.array); +if (err) +return err; + arg.array = array; + ret =get_errno (semctl (semid, semnum, cmd, arg)); + err =host_to_target_semarray (semid, target_su.array, &array); +if (err) +return err;break ;case IPC_STAT : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); -break ;case IPC_SET : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); +case SEM_STAT : + err =target_to_host_semid_ds (&dsarg, target_su.buf); +if (err) +return err; + arg.buf = &dsarg; + ret =get_errno (semctl (semid, semnum, cmd, arg)); + err =host_to_target_semid_ds (target_su.buf, &dsarg); +if (err) +return err; +break ; +case IPC_INFO : +case SEM_INFO : + arg.__buf = &seminfo; + ret =get_errno (semctl (semid, semnum, cmd, arg)); + err =host_to_target_seminfo (target_su.__buf, &seminfo); +if (err) +return err; +break ; +case IPC_RMID : +case GETPID : +case GETNCNT : +case GETZCNT : + ret =get_errno (semctl (semid, semnum, cmd,NULL ));break ; -default : - ret =get_errno (semctl (first, second, cmd, arg)); }return ret; } +struct target_sembuf { +unsigned short sem_num; +short sem_op; +short sem_flg; +}; + +static inline abi_long target_to_host_sembuf (struct sembuf *host_sembuf, +abi_ulong target_addr, +unsigned nsops) +{ +struct target_sembuf *target_sembuf; +int i; + + target_sembuf =lock_user (VERIFY_READ , target_addr, + nsops*sizeof (struct target_sembuf ),1 ); +if (!target_sembuf) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsops; i++) { +__get_user (host_sembuf[i].sem_num, &target_sembuf[i].sem_num); +__get_user (host_sembuf[i].sem_op, &target_sembuf[i].sem_op); +__get_user (host_sembuf[i].sem_flg, &target_sembuf[i].sem_flg); + } + +unlock_user (target_sembuf, target_addr,0 ); + +return 0 ; +} + +static inline abi_long do_semop (int semid,abi_long ptr,unsigned nsops) +{ +struct sembuf sops[nsops]; + +if (target_to_host_sembuf (sops, ptr, nsops)) +return -TARGET_EFAULT ; + +return semop (semid, sops, nsops); +} +struct target_msqid_ds {struct target_ipc_perm msg_perm;
@@ -2360,7 +2441,7 @@ static abi_long do_ipc(unsigned int call, int first,switch (call) {case IPCOP_semop: - ret =get_errno (semop (first,(struct sembuf *)g2h (ptr), second)); + ret =do_semop (first, ptr, second);break ;case IPCOP_semget:
@@ -2368,12 +2449,7 @@ static abi_long do_ipc(unsigned int call, int first,break ;case IPCOP_semctl: - ret =do_semctl (first, second, third, ptr); -break ; - -case IPCOP_semtimedop: -gemu_log ("Unsupported ipc call: %d (version %d)\n" , call, version); - ret = -TARGET_ENOSYS ; + ret =do_semctl (first, second, third, (union target_semun )(abi_ulong ) ptr);break ;case IPCOP_msgget:
@@ -5184,7 +5260,21 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1, ret =do_ipc (arg1, arg2, arg3, arg4, arg5, arg6);break ;#endif - +#ifdef TARGET_NR_semget +case TARGET_NR_semget: + ret =get_errno (semget (arg1, arg2, arg3)); +break ; +#endif +#ifdef TARGET_NR_semop +case TARGET_NR_semop: + ret =get_errno (do_semop (arg1, arg2, arg3)); +break ; +#endif +#ifdef TARGET_NR_semctl +case TARGET_NR_semctl: + ret =do_semctl (arg1, arg2, arg3, (union target_semun )(abi_ulong )arg4); +break ; +#endif #ifdef TARGET_NR_msgctlcase TARGET_NR_msgctl: ret =do_msgctl (arg1, arg2, arg3);
Signature · 1 line
1.6.2.1
Aurelien Jarno
AppliedRe: [Qemu-devel] [PATCH 04/10] fix IPCOP_sem* and implement sem*
Quoted 29 lines · Riku Voipio
Quoted 19 lines · Aurelien Jarno
Quoted 19 lines
linux-user/syscall.c +19
-0+struct target_sembuf { +unsigned short sem_num; +short sem_op; +short sem_flg; +}; + +static inline abi_long target_to_host_sembuf (struct sembuf *host_sembuf, +abi_ulong target_addr, +unsigned nsops) +{ +struct target_sembuf *target_sembuf; +int i; + + target_sembuf =lock_user (VERIFY_READ , target_addr, + nsops*sizeof (struct target_sembuf ),1 ); +if (!target_sembuf) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsops; i++) {Quoted 8 lines
Review
Quoted 4 lines
(quoted diff) +4
-0+ __put_user(target_sembuf[i].sem_num, &host_sembuf[i].sem_num); + __put_user(target_sembuf[i].sem_op, &host_sembuf[i].sem_op); + __put_user(target_sembuf[i].sem_flg, &host_sembuf[i].sem_flg); + }I don't follow fully the subtle difference between
__put_user()and __get_user,() but givenlock_useris called withVERIFY_READ, I think__get_user()should be used instead.
Quoted 2 lines
Yes.. since the target and host args are swapped, it still works like
__get_user. Corrected version attached.
Thanks, applied.
Quoted 401 lines
(This error appears also once in the shm* patch too)
From
32b512d9b521d2b146658f932b9c3553cd3ec1cdMon Sep 17 00:00:00 2001
From: Riku Voipio <[email protected]>
Date: Fri, 3 Apr 2009 00:28:14 +0300
Subject: [PATCH] [v2] fix IPCOP_sem* and implement sem*From: Kirill A. Shutemov <[email protected]>
Fix and cleanup IPCOP_sem* ipc calls handling and
implement sem* syscalls.Riku:
1) Uglify whitespace so that diff gets smaller and easier to review
2) use
__get_userintarget_to_host_sembufSigned-off-by Riku Voipio <[email protected]>--- linux-user/syscall.c | 286 +++++++++++++++++++++++++++++++++----------------- 1 files changed, 188 insertions(+), 98 deletions(-)linux-user/syscall.c +188
-98@@ -2005,7 +2005,8 @@ static inline abi_long target_to_host_semid_ds(struct semid_ds *host_sd,if (!lock_user_struct (VERIFY_READ , target_sd, target_addr,1 ))return -TARGET_EFAULT ; -target_to_host_ipc_perm (&(host_sd->sem_perm),target_addr); +if (target_to_host_ipc_perm (&(host_sd->sem_perm),target_addr)) +return -TARGET_EFAULT ; host_sd->sem_nsems =tswapl (target_sd->sem_nsems); host_sd->sem_otime =tswapl (target_sd->sem_otime); host_sd->sem_ctime =tswapl (target_sd->sem_ctime);@@ -2020,7 +2021,8 @@ static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,if (!lock_user_struct (VERIFY_WRITE , target_sd, target_addr,0 ))return -TARGET_EFAULT ; -host_to_target_ipc_perm (target_addr,&(host_sd->sem_perm)); +if (host_to_target_ipc_perm (target_addr,&(host_sd->sem_perm))) +return -TARGET_EFAULT ;; target_sd->sem_nsems =tswapl (host_sd->sem_nsems); target_sd->sem_otime =tswapl (host_sd->sem_otime); target_sd->sem_ctime =tswapl (host_sd->sem_ctime);@@ -2028,135 +2030,214 @@ static inline abi_long host_to_target_semid_ds(abi_ulong target_addr,return 0 ; } +struct target_seminfo { +int semmap; +int semmni; +int semmns; +int semmnu; +int semmsl; +int semopm; +int semume; +int semusz; +int semvmx; +int semaem; +}; + +static inline abi_long host_to_target_seminfo (abi_ulong target_addr, +struct seminfo *host_seminfo) +{ +struct target_seminfo *target_seminfo; +if (!lock_user_struct (VERIFY_WRITE , target_seminfo, target_addr,0 )) +return -TARGET_EFAULT ; +__put_user (host_seminfo->semmap, &target_seminfo->semmap); +__put_user (host_seminfo->semmni, &target_seminfo->semmni); +__put_user (host_seminfo->semmns, &target_seminfo->semmns); +__put_user (host_seminfo->semmnu, &target_seminfo->semmnu); +__put_user (host_seminfo->semmsl, &target_seminfo->semmsl); +__put_user (host_seminfo->semopm, &target_seminfo->semopm); +__put_user (host_seminfo->semume, &target_seminfo->semume); +__put_user (host_seminfo->semusz, &target_seminfo->semusz); +__put_user (host_seminfo->semvmx, &target_seminfo->semvmx); +__put_user (host_seminfo->semaem, &target_seminfo->semaem); +unlock_user_struct (target_seminfo, target_addr,1 ); +return 0 ; +} +union semun {int val;struct semid_ds *buf;unsigned short *array; +struct seminfo *__buf; };union target_semun {int val; -abi_long buf; -unsigned short int *array; +abi_ulong buf; +abi_ulong array; +abi_ulong __buf; }; -static inline abi_long target_to_host_semun (int cmd, -union semun *host_su, -abi_ulong target_addr, -struct semid_ds *ds) +static inline abi_long target_to_host_semarray (int semid,unsigned short **host_array, +abi_ulong target_addr) { -union target_semun *target_su; +int nsems; +unsigned short *array; +union semun semun; +struct semid_ds semid_ds; +int i, ret; -switch ( cmd ) { -case IPC_STAT : -case IPC_SET : -if (!lock_user_struct (VERIFY_READ , target_su, target_addr,1 )) -return -TARGET_EFAULT ; -target_to_host_semid_ds (ds,target_su->buf); - host_su->buf = ds; -unlock_user_struct (target_su, target_addr,0 ); -break ; -case GETVAL : -case SETVAL : -if (!lock_user_struct (VERIFY_READ , target_su, target_addr,1 )) -return -TARGET_EFAULT ; - host_su->val =tswapl (target_su->val); -unlock_user_struct (target_su, target_addr,0 ); -break ; -case GETALL : -case SETALL : -if (!lock_user_struct (VERIFY_READ , target_su, target_addr,1 )) -return -TARGET_EFAULT ; - *host_su->array =tswap16 (*target_su->array); -unlock_user_struct (target_su, target_addr,0 ); -break ; -default : -gemu_log ("semun operation not fully supported: %d\n" , (int )cmd); + semun.buf = &semid_ds; + + ret =semctl (semid,0 ,IPC_STAT , semun); +if (ret ==-1 ) +return get_errno (ret); + + nsems = semid_ds.sem_nsems; + + *host_array =malloc (nsems*sizeof (unsigned short )); + array =lock_user (VERIFY_READ , target_addr, + nsems*sizeof (unsigned short ),1 ); +if (!array) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsems; i++) { +__get_user ((*host_array)[i], &array[i]); } +unlock_user (array, target_addr,0 ); +return 0 ; } -static inline abi_long host_to_target_semun (int cmd, -abi_ulong target_addr, -union semun *host_su, -struct semid_ds *ds) +static inline abi_long host_to_target_semarray (int semid,abi_ulong target_addr, +unsigned short **host_array) { -union target_semun *target_su; +int nsems; +unsigned short *array; +union semun semun; +struct semid_ds semid_ds; +int i, ret; -switch ( cmd ) { -case IPC_STAT : -case IPC_SET : -if (lock_user_struct (VERIFY_WRITE , target_su, target_addr,0 )) -return -TARGET_EFAULT ; -host_to_target_semid_ds (target_su->buf,ds); -unlock_user_struct (target_su, target_addr,1 ); -break ; -case GETVAL : -case SETVAL : -if (lock_user_struct (VERIFY_WRITE , target_su, target_addr,0 )) -return -TARGET_EFAULT ; - target_su->val =tswapl (host_su->val); -unlock_user_struct (target_su, target_addr,1 ); -break ; -case GETALL : -case SETALL : -if (lock_user_struct (VERIFY_WRITE , target_su, target_addr,0 )) -return -TARGET_EFAULT ; - *target_su->array =tswap16 (*host_su->array); -unlock_user_struct (target_su, target_addr,1 ); -break ; -default : -gemu_log ("semun operation not fully supported: %d\n" , (int )cmd); + semun.buf = &semid_ds; + + ret =semctl (semid,0 ,IPC_STAT , semun); +if (ret ==-1 ) +return get_errno (ret); + + nsems = semid_ds.sem_nsems; + + array =lock_user (VERIFY_WRITE , target_addr, + nsems*sizeof (unsigned short ),0 ); +if (!array) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsems; i++) { +__put_user ((*host_array)[i], &array[i]); } +free (*host_array); +unlock_user (array, target_addr,1 ); +return 0 ; } -static inline abi_long do_semctl (int first,int second,int third, -abi_long ptr) +static inline abi_long do_semctl (int semid,int semnum,int cmd, +union target_semun target_su) {union semun arg;struct semid_ds dsarg; -int cmd = third&0xff ; -abi_long ret =0 ; +unsigned short *array; +struct seminfo seminfo; +abi_long ret = -TARGET_EINVAL ; +abi_long err; + cmd &=0xff ;switch ( cmd ) {case GETVAL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); -break ;case SETVAL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); + arg.val =tswapl (target_su.val); + ret =get_errno (semctl (semid, semnum, cmd, arg)); + target_su.val =tswapl (arg.val);break ;case GETALL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); -break ;case SETALL : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); + err =target_to_host_semarray (semid, &array, target_su.array); +if (err) +return err; + arg.array = array; + ret =get_errno (semctl (semid, semnum, cmd, arg)); + err =host_to_target_semarray (semid, target_su.array, &array); +if (err) +return err;break ;case IPC_STAT : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); -break ;case IPC_SET : -target_to_host_semun (cmd,&arg,ptr,&dsarg); - ret =get_errno (semctl (first, second, cmd, arg)); -host_to_target_semun (cmd,ptr,&arg,&dsarg); +case SEM_STAT : + err =target_to_host_semid_ds (&dsarg, target_su.buf); +if (err) +return err; + arg.buf = &dsarg; + ret =get_errno (semctl (semid, semnum, cmd, arg)); + err =host_to_target_semid_ds (target_su.buf, &dsarg); +if (err) +return err; +break ; +case IPC_INFO : +case SEM_INFO : + arg.__buf = &seminfo; + ret =get_errno (semctl (semid, semnum, cmd, arg)); + err =host_to_target_seminfo (target_su.__buf, &seminfo); +if (err) +return err; +break ; +case IPC_RMID : +case GETPID : +case GETNCNT : +case GETZCNT : + ret =get_errno (semctl (semid, semnum, cmd,NULL ));break ; -default : - ret =get_errno (semctl (first, second, cmd, arg)); }return ret; } +struct target_sembuf { +unsigned short sem_num; +short sem_op; +short sem_flg; +}; + +static inline abi_long target_to_host_sembuf (struct sembuf *host_sembuf, +abi_ulong target_addr, +unsigned nsops) +{ +struct target_sembuf *target_sembuf; +int i; + + target_sembuf =lock_user (VERIFY_READ , target_addr, + nsops*sizeof (struct target_sembuf ),1 ); +if (!target_sembuf) +return -TARGET_EFAULT ; + +for (i=0 ; i<nsops; i++) { +__get_user (host_sembuf[i].sem_num, &target_sembuf[i].sem_num); +__get_user (host_sembuf[i].sem_op, &target_sembuf[i].sem_op); +__get_user (host_sembuf[i].sem_flg, &target_sembuf[i].sem_flg); + } + +unlock_user (target_sembuf, target_addr,0 ); + +return 0 ; +} + +static inline abi_long do_semop (int semid,abi_long ptr,unsigned nsops) +{ +struct sembuf sops[nsops]; + +if (target_to_host_sembuf (sops, ptr, nsops)) +return -TARGET_EFAULT ; + +return semop (semid, sops, nsops); +} +struct target_msqid_ds {struct target_ipc_perm msg_perm;@@ -2360,7 +2441,7 @@ static abi_long do_ipc(unsigned int call, int first,switch (call) {case IPCOP_semop: - ret =get_errno (semop (first,(struct sembuf *)g2h (ptr), second)); + ret =do_semop (first, ptr, second);break ;case IPCOP_semget:@@ -2368,12 +2449,7 @@ static abi_long do_ipc(unsigned int call, int first,break ;case IPCOP_semctl: - ret =do_semctl (first, second, third, ptr); -break ; - -case IPCOP_semtimedop: -gemu_log ("Unsupported ipc call: %d (version %d)\n" , call, version); - ret = -TARGET_ENOSYS ; + ret =do_semctl (first, second, third, (union target_semun )(abi_ulong ) ptr);break ;case IPCOP_msgget:@@ -5184,7 +5260,21 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1, ret =do_ipc (arg1, arg2, arg3, arg4, arg5, arg6);break ;#endif - +#ifdef TARGET_NR_semget +case TARGET_NR_semget: + ret =get_errno (semget (arg1, arg2, arg3)); +break ; +#endif +#ifdef TARGET_NR_semop +case TARGET_NR_semop: + ret =get_errno (do_semop (arg1, arg2, arg3)); +break ; +#endif +#ifdef TARGET_NR_semctl +case TARGET_NR_semctl: + ret =do_semctl (arg1, arg2, arg3, (union target_semun )(abi_ulong )arg4); +break ; +#endif #ifdef TARGET_NR_msgctlcase TARGET_NR_msgctl: ret =do_msgctl (arg1, arg2, arg3);Signature · 1 line
1.6.2.1
Signature · 2 lines
Aurelien Jarno GPG: 1024D/F1BCDB73 [email protected] http://www.aurel32.net
PATCH 5/10 Added posix message queue syscalls except mq_notify
In reply to [email protected]From: Lionel Landwerlin <[email protected]>
From: Lionel Landwerlin <[email protected]>
Added Added posix message queue syscalls and their strace prints.
From: Lionel Landwerlin <[email protected]>
--- linux-user/strace.list | 12 ++-- linux-user/syscall.c | 113 +++++++++++++++++++++++++++++++++++++++++++++ linux-user/syscall_defs.h | 7 +++ 3 files changed, 126 insertions(+), 6 deletions(-)
linux-user/strace.list +6 -6
@@ -524,22 +524,22 @@ { TARGET_NR_mpx, "mpx" , NULL, NULL, NULL }, #endif #ifdef TARGET_NR_mq_getsetattr -{ TARGET_NR_mq_getsetattr, "mq_getsetattr" , NULL, NULL, NULL }, +{ TARGET_NR_mq_getsetattr, "mq_getsetattr" , "%s(%d,%p,%p)", NULL, NULL }, #endif #ifdef TARGET_NR_mq_notify -{ TARGET_NR_mq_notify, "mq_notify" , NULL, NULL, NULL }, +{ TARGET_NR_mq_notify, "mq_notify" , "%s(%d,%p)", NULL, NULL }, #endif #ifdef TARGET_NR_mq_open -{ TARGET_NR_mq_open, "mq_open" , NULL, NULL, NULL }, +{ TARGET_NR_mq_open, "mq_open" , "%s(\"/%s\",%#x,%#o,%p)", NULL, NULL }, #endif #ifdef TARGET_NR_mq_timedreceive -{ TARGET_NR_mq_timedreceive, "mq_timedreceive" , NULL, NULL, NULL }, +{ TARGET_NR_mq_timedreceive, "mq_timedreceive" , "%s(%d,%p,%d,%u,%p)", NULL, NULL }, #endif #ifdef TARGET_NR_mq_timedsend -{ TARGET_NR_mq_timedsend, "mq_timedsend" , NULL, NULL, NULL }, +{ TARGET_NR_mq_timedsend, "mq_timedsend" , "%s(%d,%p,%d,%u,%p)", NULL, NULL }, #endif #ifdef TARGET_NR_mq_unlink -{ TARGET_NR_mq_unlink, "mq_unlink" , NULL, NULL, NULL }, +{ TARGET_NR_mq_unlink, "mq_unlink" , "%s(%s)", NULL, NULL }, #endif #ifdef TARGET_NR_mremap { TARGET_NR_mremap, "mremap" , NULL, NULL, NULL },
linux-user/syscall.c +113 -0
131 lines not on this page · raw message
linux-user/syscall_defs.h +7 -0
@@ -1998,6 +1998,13 @@ struct linux_dirent64 {char d_name[256 ]; }; +struct target_mq_attr { +abi_long mq_flags; +abi_long mq_maxmsg; +abi_long mq_msgsize; +abi_long mq_curmsgs; +}; +#include "socket.h" #include "errno_defs.h"
Signature · 1 line
1.6.2.1
Aurelien Jarno
AppliedRe: [Qemu-devel] [PATCH 05/10] Added posix message queue syscalls except mq_notify
Quoted 9 lines · On Sun, Apr 05, 2009 at 11:59:21PM +0300, [email protected] wrote:
From: Lionel Landwerlin <[email protected]>
From: Lionel Landwerlin <[email protected]>
Added Added posix message queue syscalls and their strace prints.
From: Lionel Landwerlin <[email protected]>
Quoted 8 lines
Signed-off-by Lionel Landwerlin <[email protected]>Signed-off-by Kirill A. Shutemov <[email protected]>Signed-off-by Riku Voipio <[email protected]>--- linux-user/strace.list | 12 ++-- linux-user/syscall.c | 113 +++++++++++++++++++++++++++++++++++++++++++++ linux-user/syscall_defs.h | 7 +++ 3 files changed, 126 insertions(+), 6 deletions(-)
Thanks, applied.
Quoted 195 lines
linux-user/strace.list +6
-6@@ -524,22 +524,22 @@ { TARGET_NR_mpx, "mpx" , NULL, NULL, NULL }, #endif #ifdef TARGET_NR_mq_getsetattr -{ TARGET_NR_mq_getsetattr, "mq_getsetattr" , NULL, NULL, NULL }, +{ TARGET_NR_mq_getsetattr, "mq_getsetattr" , "%s(%d,%p,%p)", NULL, NULL }, #endif #ifdef TARGET_NR_mq_notify -{ TARGET_NR_mq_notify, "mq_notify" , NULL, NULL, NULL }, +{ TARGET_NR_mq_notify, "mq_notify" , "%s(%d,%p)", NULL, NULL }, #endif #ifdef TARGET_NR_mq_open -{ TARGET_NR_mq_open, "mq_open" , NULL, NULL, NULL }, +{ TARGET_NR_mq_open, "mq_open" , "%s(\"/%s\",%#x,%#o,%p)", NULL, NULL }, #endif #ifdef TARGET_NR_mq_timedreceive -{ TARGET_NR_mq_timedreceive, "mq_timedreceive" , NULL, NULL, NULL }, +{ TARGET_NR_mq_timedreceive, "mq_timedreceive" , "%s(%d,%p,%d,%u,%p)", NULL, NULL }, #endif #ifdef TARGET_NR_mq_timedsend -{ TARGET_NR_mq_timedsend, "mq_timedsend" , NULL, NULL, NULL }, +{ TARGET_NR_mq_timedsend, "mq_timedsend" , "%s(%d,%p,%d,%u,%p)", NULL, NULL }, #endif #ifdef TARGET_NR_mq_unlink -{ TARGET_NR_mq_unlink, "mq_unlink" , NULL, NULL, NULL }, +{ TARGET_NR_mq_unlink, "mq_unlink" , "%s(%s)", NULL, NULL }, #endif #ifdef TARGET_NR_mremap { TARGET_NR_mremap, "mremap" , NULL, NULL, NULL },linux-user/syscall.c +113
-0@@ -29,6 +29,7 @@#include <fcntl.h> #include <time.h> #include <limits.h> +#include <mqueue.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> @@ -635,6 +636,43 @@ static inline abi_long copy_to_user_timeval(abi_ulong target_tv_addr,return 0 ; } +static inline abi_long copy_from_user_mq_attr (struct mq_attr *attr, +abi_ulong target_mq_attr_addr) +{ +struct target_mq_attr *target_mq_attr; + +if (!lock_user_struct (VERIFY_READ , target_mq_attr, + target_mq_attr_addr,1 )) +return -TARGET_EFAULT ; + +__get_user (attr->mq_flags, &target_mq_attr->mq_flags); +__get_user (attr->mq_maxmsg, &target_mq_attr->mq_maxmsg); +__get_user (attr->mq_msgsize, &target_mq_attr->mq_msgsize); +__get_user (attr->mq_curmsgs, &target_mq_attr->mq_curmsgs); + +unlock_user_struct (target_mq_attr, target_mq_attr_addr,0 ); + +return 0 ; +} + +static inline abi_long copy_to_user_mq_attr (abi_ulong target_mq_attr_addr, +const struct mq_attr *attr) +{ +struct target_mq_attr *target_mq_attr; + +if (!lock_user_struct (VERIFY_WRITE , target_mq_attr, + target_mq_attr_addr,0 )) +return -TARGET_EFAULT ; + +__put_user (attr->mq_flags, &target_mq_attr->mq_flags); +__put_user (attr->mq_maxmsg, &target_mq_attr->mq_maxmsg); +__put_user (attr->mq_msgsize, &target_mq_attr->mq_msgsize); +__put_user (attr->mq_curmsgs, &target_mq_attr->mq_curmsgs); + +unlock_user_struct (target_mq_attr, target_mq_attr_addr,1 ); + +return 0 ; +}/* do_select() must return target values and target errnos. */ static abi_long do_select(int n,@@ -6439,6 +6477,81 @@ abi_long do_syscall(void *cpu_env, int num, abi_long arg1,break ;#endif +#ifdef TARGET_NR_mq_open +case TARGET_NR_mq_open: + { +struct mq_attr posix_mq_attr; + + p =lock_user_string (arg1 -1 ); +if (arg4 !=0 ) +copy_from_user_mq_attr (&posix_mq_attr, arg4); + ret =get_errno (mq_open (p, arg2, arg3, &posix_mq_attr)); +unlock_user (p, arg1,0 ); +break ; + } + +case TARGET_NR_mq_unlink: + p =lock_user_string (arg1 -1 ); + ret =get_errno (mq_unlink (p)); +unlock_user (p, arg1,0 ); +break ; + +case TARGET_NR_mq_timedsend: + { +struct timespec ts; + + p =lock_user (VERIFY_READ , arg2, arg3,1 ); +if (arg5 !=0 ) { +target_to_host_timespec (&ts, arg5); + ret =get_errno (mq_timedsend (arg1, p, arg3, arg4, &ts)); +host_to_target_timespec (arg5, &ts); + } +else + ret =get_errno (mq_send (arg1, p, arg3, arg4)); +unlock_user (p, arg2, arg3); +break ; + } + +case TARGET_NR_mq_timedreceive: + { +struct timespec ts; +unsigned int prio; + + p =lock_user (VERIFY_READ , arg2, arg3,1 ); +if (arg5 !=0 ) { +target_to_host_timespec (&ts, arg5); + ret =get_errno (mq_timedreceive (arg1, p, arg3, &prio, &ts)); +host_to_target_timespec (arg5, &ts); + } +else + ret =get_errno (mq_receive (arg1, p, arg3, &prio)); +unlock_user (p, arg2, arg3); +if (arg4 !=0 ) +put_user_u32 (prio, arg4); +break ; + } + +/* Not implemented for now... */ +/* case TARGET_NR_mq_notify: */ +/* break; */ + +case TARGET_NR_mq_getsetattr: + { +struct mq_attr posix_mq_attr_in, posix_mq_attr_out; + ret =0 ; +if (arg3 !=0 ) { + ret =mq_getattr (arg1, &posix_mq_attr_out); +copy_to_user_mq_attr (arg3, &posix_mq_attr_out); + } +if (arg2 !=0 ) { +copy_from_user_mq_attr (&posix_mq_attr_in, arg2); + ret |=mq_setattr (arg1, &posix_mq_attr_in, &posix_mq_attr_out); + } + +break ; + } +#endif +default : unimplemented:gemu_log ("qemu: Unsupported syscall: %d\n" , num);linux-user/syscall_defs.h +7
-0@@ -1998,6 +1998,13 @@ struct linux_dirent64 {char d_name[256 ]; }; +struct target_mq_attr { +abi_long mq_flags; +abi_long mq_maxmsg; +abi_long mq_msgsize; +abi_long mq_curmsgs; +}; +#include "socket.h" #include "errno_defs.h" Signature · 1 line
1.6.2.1
Signature · 2 lines
Aurelien Jarno GPG: 1024D/F1BCDB73 [email protected] http://www.aurel32.net
PATCH 6/10 Add support for passing contents of argv0
In reply to [email protected]From: Riku Voipio <[email protected]>
Added switch -0 (zero) which can be used to pass argv[0] to target process. The main use is for a binfmt_misc wrapper when the "P - preserve-argv[0]" setting is used.
From: Mika Westerberg
--- linux-user/main.c | 38 +++++++++++++++++++++++++++++++++++++- 1 files changed, 37 insertions(+), 1 deletions(-)
linux-user/main.c +37 -1
@@ -2213,6 +2213,7 @@ static void usage(void)"-drop-ld-preload drop LD_PRELOAD for target process\n" "-E var=value sets/modifies targets environment variable(s)\n" "-U var unsets targets environment variable(s)\n" +"-0 argv0 forces target process argv[0] to be argv0\n" "\n" "Debug options:\n" "-d options activate log (logfile=%s)\n"
@@ -2263,7 +2264,11 @@ int main(int argc, char **argv, char **envp)const char *r;int gdbstub_port =0 ;char **target_environ, **wrk; +char **target_argv; +int target_argc;envlist_t *envlist =NULL ; +const char *argv0 =NULL ; +int i;if (argc <=1 )usage ();
@@ -2320,6 +2325,9 @@ int main(int argc, char **argv, char **envp) r = argv[optind++];if (envlist_unsetenv (envlist, r) !=0 )usage (); + }else if (!strcmp (r,"0" )) { + r = argv[optind++]; + argv0 = r; }else if (!strcmp (r,"s" )) {if (optind >= argc)break ;
@@ -2430,11 +2438,39 @@ int main(int argc, char **argv, char **envp) target_environ =envlist_to_environ (envlist,NULL );envlist_free (envlist); -if (loader_exec (filename, argv+optind, target_environ, regs, info) !=0 ) { +/* +* Prepare copy of argv vector for target. +*/ + target_argc = argc - optind; + target_argv =calloc (target_argc +1 ,sizeof (char *)); +if (target_argv ==NULL ) { + (void )fprintf (stderr,"Unable to allocate memory for target_argv\n" ); +exit (1 ); + } + +/* +* If argv0 is specified (using '-0' switch) we replace +* argv[0] pointer with the given one. +*/ + i =0 ; +if (argv0 !=NULL ) { + target_argv[i++] =strdup (argv0); + } +for (; i < target_argc; i++) { + target_argv[i] =strdup (argv[optind + i]); + } + target_argv[target_argc] =NULL ; + +if (loader_exec (filename, target_argv, target_environ, regs, info) !=0 ) {printf ("Error loading %s\n" , filename);_exit (1 ); } +for (i =0 ; i < target_argc; i++) { +free (target_argv[i]); + } +free (target_argv); +for (wrk = target_environ; *wrk; wrk++) {free (*wrk); }
Signature · 1 line
1.6.2.1
Aurelien Jarno
AppliedRe: [Qemu-devel] [PATCH 06/10] Add support for passing contents of argv0
Quoted 6 lines · On Sun, Apr 05, 2009 at 11:59:22PM +0300, [email protected] wrote:
From: Riku Voipio <[email protected]>
Added switch -0 (zero) which can be used to pass argv[0] to target process. The main use is for a
binfmt_miscwrapper when the "P - preserve-argv[0]" setting is used.
Quoted 6 lines
From: Mika Westerberg
Signed-off-by Riku Voipio <[email protected]>--- linux-user/main.c | 38 +++++++++++++++++++++++++++++++++++++- 1 files changed, 37 insertions(+), 1 deletions(-)
Thanks, applied.
Quoted 81 lines
linux-user/main.c +37
-1@@ -2213,6 +2213,7 @@ static void usage(void)"-drop-ld-preload drop LD_PRELOAD for target process\n" "-E var=value sets/modifies targets environment variable(s)\n" "-U var unsets targets environment variable(s)\n" +"-0 argv0 forces target process argv[0] to be argv0\n" "\n" "Debug options:\n" "-d options activate log (logfile=%s)\n" @@ -2263,7 +2264,11 @@ int main(int argc, char **argv, char **envp)const char *r;int gdbstub_port =0 ;char **target_environ, **wrk; +char **target_argv; +int target_argc;envlist_t *envlist =NULL ; +const char *argv0 =NULL ; +int i;if (argc <=1 )usage ();@@ -2320,6 +2325,9 @@ int main(int argc, char **argv, char **envp) r = argv[optind++];if (envlist_unsetenv (envlist, r) !=0 )usage (); + }else if (!strcmp (r,"0" )) { + r = argv[optind++]; + argv0 = r; }else if (!strcmp (r,"s" )) {if (optind >= argc)break ;@@ -2430,11 +2438,39 @@ int main(int argc, char **argv, char **envp) target_environ =envlist_to_environ (envlist,NULL );envlist_free (envlist); -if (loader_exec (filename, argv+optind, target_environ, regs, info) !=0 ) { +/* +* Prepare copy of argv vector for target. +*/ + target_argc = argc - optind; + target_argv =calloc (target_argc +1 ,sizeof (char *)); +if (target_argv ==NULL ) { + (void )fprintf (stderr,"Unable to allocate memory for target_argv\n" ); +exit (1 ); + } + +/* +* If argv0 is specified (using '-0' switch) we replace +* argv[0] pointer with the given one. +*/ + i =0 ; +if (argv0 !=NULL ) { + target_argv[i++] =strdup (argv0); + } +for (; i < target_argc; i++) { + target_argv[i] =strdup (argv[optind + i]); + } + target_argv[target_argc] =NULL ; + +if (loader_exec (filename, target_argv, target_environ, regs, info) !=0 ) {printf ("Error loading %s\n" , filename);_exit (1 ); } +for (i =0 ; i < target_argc; i++) { +free (target_argv[i]); + } +free (target_argv); +for (wrk = target_environ; *wrk; wrk++) {free (*wrk); }Signature · 1 line
1.6.2.1
Signature · 2 lines
Aurelien Jarno GPG: 1024D/F1BCDB73 [email protected] http://www.aurel32.net
PATCH 7/10 linux-user: unix sockets - fix running dbus
In reply to [email protected]From: Riku Voipio <[email protected]>
dbus sends too short (according to man 7 unix) addrlen for it's unix socket. I've been told that happens with other applications as well. Linux kernel doesn't appear to mind, so I guess we whould be tolerant as well. Expand sockaddr with +1 to fit the \0 of the pathname passed.
(scratchbox1 qemu had a very different workaround for the same issue).
--- linux-user/syscall.c | 29 +++++++++++++++++++++++++++-- 1 files changed, 27 insertions(+), 2 deletions(-)
linux-user/syscall.c +27 -2
@@ -44,6 +44,7 @@#include <signal.h> #include <sched.h> #include <sys/socket.h> +#include <sys/un.h> #include <sys/uio.h> #include <sys/poll.h> #include <sys/times.h>
@@ -735,13 +736,37 @@ static inline abi_long target_to_host_sockaddr(struct sockaddr *addr, abi_ulong target_addr, socklen_t len) { +const socklen_t unix_maxlen =sizeof (struct sockaddr_un ); +sa_family_t sa_family;struct target_sockaddr *target_saddr; target_saddr =lock_user (VERIFY_READ , target_addr, len,1 );if (!target_saddr)return -TARGET_EFAULT ; + + sa_family =tswap16 (target_saddr->sa_family); + +/* Oops. The caller might send a incomplete sun_path; sun_path +* must be terminated by \0 (see the manual page), but +* unfortunately it is quite common to specify sockaddr_un +* length as "strlen(x->sun_path)" while it should be +* "strlen(...) + 1". We'll fix that here if needed. +* Linux kernel has a similar feature. +*/ + +if (sa_family ==AF_UNIX ) { +if (len < unix_maxlen && len >0 ) { +char *cp = (char *)target_saddr; + +if ( cp[len-1 ] && !cp[len] ) + len++; + } +if (len > unix_maxlen) + len = unix_maxlen; + } +memcpy (addr, target_saddr, len); - addr->sa_family =tswap16 (target_saddr->sa_family); + addr->sa_family = sa_family;unlock_user (target_saddr, target_addr,0 );return 0 ;
@@ -1195,7 +1220,7 @@ static abi_long do_bind(int sockfd, abi_ulong target_addr,if (addrlen <0 || addrlen >MAX_SOCK_ADDR )return -TARGET_EINVAL ; - addr =alloca (addrlen); + addr =alloca (addrlen+1 );target_to_host_sockaddr (addr, target_addr, addrlen);return get_errno (bind (sockfd, addr, addrlen));
Signature · 1 line
1.6.2.1
Aurelien Jarno
AppliedRe: [Qemu-devel] [PATCH 07/10] linux-user: unix sockets - fix running dbus
Quoted 8 lines · On Sun, Apr 05, 2009 at 11:59:23PM +0300, [email protected] wrote:
From: Riku Voipio <[email protected]>
dbus sends too short (according to man 7 unix) addrlen for it's unix socket. I've been told that happens with other applications as well. Linux kernel doesn't appear to mind, so I guess we whould be tolerant as well. Expand sockaddr with +1 to fit the \0 of the pathname passed.
Quoted 6 lines
(scratchbox1 qemu had a very different workaround for the same issue).
Signed-off-by Riku Voipio <[email protected]>--- linux-user/syscall.c | 29 +++++++++++++++++++++++++++-- 1 files changed, 27 insertions(+), 2 deletions(-)
Thanks, applied.
Quoted 66 lines
linux-user/syscall.c +27
-2@@ -44,6 +44,7 @@#include <signal.h> #include <sched.h> #include <sys/socket.h> +#include <sys/un.h> #include <sys/uio.h> #include <sys/poll.h> #include <sys/times.h> @@ -735,13 +736,37 @@ static inline abi_long target_to_host_sockaddr(struct sockaddr *addr, abi_ulong target_addr, socklen_t len) { +const socklen_t unix_maxlen =sizeof (struct sockaddr_un ); +sa_family_t sa_family;struct target_sockaddr *target_saddr; target_saddr =lock_user (VERIFY_READ , target_addr, len,1 );if (!target_saddr)return -TARGET_EFAULT ; + + sa_family =tswap16 (target_saddr->sa_family); + +/* Oops. The caller might send a incomplete sun_path; sun_path +* must be terminated by \0 (see the manual page), but +* unfortunately it is quite common to specify sockaddr_un +* length as "strlen(x->sun_path)" while it should be +* "strlen(...) + 1". We'll fix that here if needed. +* Linux kernel has a similar feature. +*/ + +if (sa_family ==AF_UNIX ) { +if (len < unix_maxlen && len >0 ) { +char *cp = (char *)target_saddr; + +if ( cp[len-1 ] && !cp[len] ) + len++; + } +if (len > unix_maxlen) + len = unix_maxlen; + } +memcpy (addr, target_saddr, len); - addr->sa_family =tswap16 (target_saddr->sa_family); + addr->sa_family = sa_family;unlock_user (target_saddr, target_addr,0 );return 0 ;@@ -1195,7 +1220,7 @@ static abi_long do_bind(int sockfd, abi_ulong target_addr,if (addrlen <0 || addrlen >MAX_SOCK_ADDR )return -TARGET_EINVAL ; - addr =alloca (addrlen); + addr =alloca (addrlen+1 );target_to_host_sockaddr (addr, target_addr, addrlen);return get_errno (bind (sockfd, addr, addrlen));Signature · 1 line
1.6.2.1
Signature · 2 lines
Aurelien Jarno GPG: 1024D/F1BCDB73 [email protected] http://www.aurel32.net
PATCH 8/10 linux-user: removed unnecessary MAX_SOCK_ADDR checks for socket syscalls
In reply to [email protected]From: Mika Westerberg <[email protected]>
- This check is not needed because kernel will check whether given buffer is too small and there is no upper limit for size of the buffer.
From: Mika Westerberg <[email protected]>
--- linux-user/syscall.c | 17 +++++++---------- 1 files changed, 7 insertions(+), 10 deletions(-)
linux-user/syscall.c +7 -10
@@ -1208,16 +1208,13 @@ static abi_long do_socket(int domain, int type, int protocol)return get_errno (socket (domain, type, protocol)); } -/* MAX_SOCK_ADDR from linux/net/socket.c */ -#define MAX_SOCK_ADDR 128 -/* do_bind() Must return target values and target errnos. */ static abi_long do_bind (int sockfd,abi_ulong target_addr,socklen_t addrlen) {void *addr; -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) +if (addrlen <0 )return -TARGET_EINVAL ; addr =alloca (addrlen+1 );
@@ -1232,7 +1229,7 @@ static abi_long do_connect(int sockfd, abi_ulong target_addr, {void *addr; -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) +if (addrlen <0 )return -TARGET_EINVAL ; addr =alloca (addrlen);
@@ -1307,7 +1304,7 @@ static abi_long do_accept(int fd, abi_ulong target_addr,if (get_user_u32 (addrlen, target_addrlen_addr))return -TARGET_EFAULT ; -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) +if (addrlen <0 )return -TARGET_EINVAL ; addr =alloca (addrlen);
@@ -1332,7 +1329,7 @@ static abi_long do_getpeername(int fd, abi_ulong target_addr,if (get_user_u32 (addrlen, target_addrlen_addr))return -TARGET_EFAULT ; -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) +if (addrlen <0 )return -TARGET_EINVAL ; addr =alloca (addrlen);
@@ -1360,7 +1357,7 @@ static abi_long do_getsockname(int fd, abi_ulong target_addr,if (get_user_u32 (addrlen, target_addrlen_addr))return -TARGET_EFAULT ; -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) +if (addrlen <0 )return -TARGET_EINVAL ; addr =alloca (addrlen);
@@ -1398,7 +1395,7 @@ static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags,void *host_msg;abi_long ret; -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) +if (addrlen <0 )return -TARGET_EINVAL ; host_msg =lock_user (VERIFY_READ , msg, len,1 );
@@ -1433,7 +1430,7 @@ static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags, ret = -TARGET_EFAULT ; goto fail; } -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) { +if (addrlen <0 ) { ret = -TARGET_EINVAL ; goto fail; }
Signature · 1 line
1.6.2.1
Aurelien Jarno
AppliedRe: [Qemu-devel] [PATCH 08/10] linux-user: removed unnecessary MAX_SOCK_ADDR checks for socket syscalls
Quoted 11 lines · On Sun, Apr 05, 2009 at 11:59:24PM +0300, [email protected] wrote:
From: Mika Westerberg <[email protected]>
- This check is not needed because kernel will check whether given buffer is too small and there is no upper limit for size of the buffer.
From: Mika Westerberg <[email protected]>
Signed-off-by Riku Voipio <[email protected]>--- linux-user/syscall.c | 17 +++++++---------- 1 files changed, 7 insertions(+), 10 deletions(-)
Thanks, applied.
Quoted 82 lines
linux-user/syscall.c +7
-10@@ -1208,16 +1208,13 @@ static abi_long do_socket(int domain, int type, int protocol)return get_errno (socket (domain, type, protocol)); } -/* MAX_SOCK_ADDR from linux/net/socket.c */ -#define MAX_SOCK_ADDR 128 -/* do_bind() Must return target values and target errnos. */ static abi_long do_bind (int sockfd,abi_ulong target_addr,socklen_t addrlen) {void *addr; -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) +if (addrlen <0 )return -TARGET_EINVAL ; addr =alloca (addrlen+1 );@@ -1232,7 +1229,7 @@ static abi_long do_connect(int sockfd, abi_ulong target_addr, {void *addr; -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) +if (addrlen <0 )return -TARGET_EINVAL ; addr =alloca (addrlen);@@ -1307,7 +1304,7 @@ static abi_long do_accept(int fd, abi_ulong target_addr,if (get_user_u32 (addrlen, target_addrlen_addr))return -TARGET_EFAULT ; -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) +if (addrlen <0 )return -TARGET_EINVAL ; addr =alloca (addrlen);@@ -1332,7 +1329,7 @@ static abi_long do_getpeername(int fd, abi_ulong target_addr,if (get_user_u32 (addrlen, target_addrlen_addr))return -TARGET_EFAULT ; -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) +if (addrlen <0 )return -TARGET_EINVAL ; addr =alloca (addrlen);@@ -1360,7 +1357,7 @@ static abi_long do_getsockname(int fd, abi_ulong target_addr,if (get_user_u32 (addrlen, target_addrlen_addr))return -TARGET_EFAULT ; -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) +if (addrlen <0 )return -TARGET_EINVAL ; addr =alloca (addrlen);@@ -1398,7 +1395,7 @@ static abi_long do_sendto(int fd, abi_ulong msg, size_t len, int flags,void *host_msg;abi_long ret; -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) +if (addrlen <0 )return -TARGET_EINVAL ; host_msg =lock_user (VERIFY_READ , msg, len,1 );@@ -1433,7 +1430,7 @@ static abi_long do_recvfrom(int fd, abi_ulong msg, size_t len, int flags, ret = -TARGET_EFAULT ; goto fail; } -if (addrlen <0 || addrlen >MAX_SOCK_ADDR ) { +if (addrlen <0 ) { ret = -TARGET_EINVAL ; goto fail; }Signature · 1 line
1.6.2.1
Signature · 2 lines
Aurelien Jarno GPG: 1024D/F1BCDB73 [email protected] http://www.aurel32.net
PATCH 9/10 Prefer glibc over direct syscalls
In reply to [email protected]From: Riku Voipio <[email protected]>
The openat/*at syscalls are incredibly common with modern coreutils, calling them directly via syscalls breaks for example fakeroot. Use glibc stubs whenever directly available and provide old syscall calling for people still using older libc.
Patch originally from Mika Westerberg, Adapted to apply to current trunk and cleaned up by Riku Voipio.
--- configure | 53 +++++++++ linux-user/syscall.c | 314 ++++++++++++++++++++++++++++++++++++++++---------- 2 files changed, 306 insertions(+), 61 deletions(-)
configure +53 -0
@@ -1115,6 +1115,53 @@ EOF fi fi +# +# Check for xxxat() functions when we are building linux-user +# emulator. This is done because older glibc versions don't +# have syscall stubs for these implemented. +# +atfile=no +if [ "$linux_user" = "yes" ] ; then + cat > $TMPC << EOF +#define _ATFILE_SOURCE +#include <sys/types.h> +#include <fcntl.h> +#include <unistd.h> + +int +main(void) +{ + /* try to unlink nonexisting file */ + return (unlinkat(AT_FDCWD, "nonexistent_file", 0)); +} +EOF + if $cc $ARCH_CFLAGS -o $TMPE $TMPC 2> /dev/null ; then + atfile=yes + fi +fi + +# Check for initofy functions when we are building linux-user +# emulator. This is done because older glibc versions don't +# have syscall stubs for these implemented. In that case we +# don't provide them even if kernel supports them. +# +inotify=no +if [ "$linux_user" = "yes" ] ; then + cat > $TMPC << EOF +#include <sys/inotify.h> + +int +main(void) +{ + /* try to start inotify */ + return inotify_init(void); +} +EOF + if $cc $ARCH_CFLAGS -o $TMPE $TMPC 2> /dev/null ; then + inotify=yes + fi +fi + # Check if tools are available to build documentation. if [ -x "`which texi2html 2>/dev/null`" ] && \ [ -x "`which pod2man 2>/dev/null`" ]; then
@@ -1494,6 +1541,12 @@ if test "$curses" = "yes" ; then echo "CONFIG_CURSES=yes" >> $config_mak echo "CURSES_LIBS=-lcurses" >> $config_mak fi +if test "$atfile" = "yes" ; then + echo "#define CONFIG_ATFILE 1" >> $config_h +fi +if test "$inotify" = "yes" ; then + echo "#define CONFIG_INOTIFY 1" >> $config_h +fi if test "$brlapi" = "yes" ; then echo "CONFIG_BRLAPI=yes" >> $config_mak echo "#define CONFIG_BRLAPI 1" >> $config_h
linux-user/syscall.c +253 -61
369 lines not on this page · raw message
Signature · 1 line
1.6.2.1
Aurelien Jarno
AppliedRe: [Qemu-devel] [PATCH 09/10] Prefer glibc over direct syscalls
Quoted 7 lines · On Sun, Apr 05, 2009 at 11:59:25PM +0300, [email protected] wrote:
From: Riku Voipio <[email protected]>
The openat/*at syscalls are incredibly common with modern coreutils, calling them directly via syscalls breaks for example fakeroot. Use glibc stubs whenever directly available and provide old syscall calling for people still using older libc.
Quoted 8 lines
Patch originally from Mika Westerberg, Adapted to apply to current trunk and cleaned up by Riku Voipio.
Signed-off-by Riku Voipio <[email protected]>--- configure | 53 +++++++++ linux-user/syscall.c | 314 ++++++++++++++++++++++++++++++++++++++++---------- 2 files changed, 306 insertions(+), 61 deletions(-)
Thanks, applied.
Quoted 457 lines
configure +53
-0@@ -1115,6 +1115,53 @@ EOF fi fi +# +# Check for xxxat() functions when we are building linux-user +# emulator. This is done because older glibc versions don't +# have syscall stubs for these implemented. +# +atfile=no +if [ "$linux_user" = "yes" ] ; then + cat > $TMPC << EOF +#define _ATFILE_SOURCE +#include <sys/types.h> +#include <fcntl.h> +#include <unistd.h> + +int +main(void) +{ + /* try to unlink nonexisting file */ + return (unlinkat(AT_FDCWD, "nonexistent_file", 0)); +} +EOF + if $cc $ARCH_CFLAGS -o $TMPE $TMPC 2> /dev/null ; then + atfile=yes + fi +fi + +# Check for initofy functions when we are building linux-user +# emulator. This is done because older glibc versions don't +# have syscall stubs for these implemented. In that case we +# don't provide them even if kernel supports them. +# +inotify=no +if [ "$linux_user" = "yes" ] ; then + cat > $TMPC << EOF +#include <sys/inotify.h> + +int +main(void) +{ + /* try to start inotify */ + return inotify_init(void); +} +EOF + if $cc $ARCH_CFLAGS -o $TMPE $TMPC 2> /dev/null ; then + inotify=yes + fi +fi + # Check if tools are available to build documentation. if [ -x "`which texi2html 2>/dev/null`" ] && \ [ -x "`which pod2man 2>/dev/null`" ]; then@@ -1494,6 +1541,12 @@ if test "$curses" = "yes" ; then echo "CONFIG_CURSES=yes" >> $config_mak echo "CURSES_LIBS=-lcurses" >> $config_mak fi +if test "$atfile" = "yes" ; then + echo "#define CONFIG_ATFILE 1" >> $config_h +fi +if test "$inotify" = "yes" ; then + echo "#define CONFIG_INOTIFY 1" >> $config_h +fi if test "$brlapi" = "yes" ; then echo "CONFIG_BRLAPI=yes" >> $config_mak echo "#define CONFIG_BRLAPI 1" >> $config_hlinux-user/syscall.c +253
-61@@ -53,6 +53,7 @@#include <sys/statfs.h> #include <utime.h> #include <sys/sysinfo.h> +#include <sys/utsname.h> //#include <sys/user.h> #include <netinet/ip.h> #include <netinet/tcp.h> @@ -200,7 +201,229 @@ static int gettid(void) {return -ENOSYS ; }#endif -_syscall1(int,sys_uname,struct new_utsname *,buf) +#if TARGET_ABI_BITS ==32 +_syscall3(int, sys_getdents, uint, fd, struct linux_dirent *, dirp, uint, count); +#endif +#if defined(TARGET_NR_getdents64) && defined(__NR_getdents64) +_syscall3(int, sys_getdents64, uint, fd, struct linux_dirent64 *, dirp, uint, count); +#endif +_syscall2 (int, sys_getpriority, int, which, int, who); +#if !defined (__x86_64__) +_syscall5 (int, _llseek, uint, fd, ulong, hi, ulong, lo, + loff_t *, res, uint, wh); +#endif +_syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo) +_syscall3(int,sys_syslog,int,type,char*,bufp,int,len) +#if defined(TARGET_NR_tgkill) && defined(__NR_tgkill) +_syscall3(int,sys_tgkill,int,tgid,int,pid,int,sig) +#endif +#if defined(TARGET_NR_tkill) && defined(__NR_tkill) +_syscall2(int,sys_tkill,int,tid,int,sig) +#endif +#ifdef __NR_exit_group +_syscall1(int,exit_group,int,error_code) +#endif +#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address) +_syscall1(int,set_tid_address,int *,tidptr) +#endif +#if defined(USE_NPTL ) +#if defined(TARGET_NR_futex) && defined(__NR_futex) +_syscall6(int,sys_futex,int *,uaddr,int,op,int,val, + const struct timespec *,timeout,int *,uaddr2,int,val3) +#endif +#endif + +static bitmask_transtbl fcntl_flags_tbl[] = { + {TARGET_O_ACCMODE ,TARGET_O_WRONLY ,O_ACCMODE ,O_WRONLY , }, + {TARGET_O_ACCMODE ,TARGET_O_RDWR ,O_ACCMODE ,O_RDWR , }, + {TARGET_O_CREAT ,TARGET_O_CREAT ,O_CREAT ,O_CREAT , }, + {TARGET_O_EXCL ,TARGET_O_EXCL ,O_EXCL ,O_EXCL , }, + {TARGET_O_NOCTTY ,TARGET_O_NOCTTY ,O_NOCTTY ,O_NOCTTY , }, + {TARGET_O_TRUNC ,TARGET_O_TRUNC ,O_TRUNC ,O_TRUNC , }, + {TARGET_O_APPEND ,TARGET_O_APPEND ,O_APPEND ,O_APPEND , }, + {TARGET_O_NONBLOCK ,TARGET_O_NONBLOCK ,O_NONBLOCK ,O_NONBLOCK , }, + {TARGET_O_SYNC ,TARGET_O_SYNC ,O_SYNC ,O_SYNC , }, + {TARGET_FASYNC ,TARGET_FASYNC ,FASYNC ,FASYNC , }, + {TARGET_O_DIRECTORY ,TARGET_O_DIRECTORY ,O_DIRECTORY ,O_DIRECTORY , }, + {TARGET_O_NOFOLLOW ,TARGET_O_NOFOLLOW ,O_NOFOLLOW ,O_NOFOLLOW , }, + {TARGET_O_LARGEFILE ,TARGET_O_LARGEFILE ,O_LARGEFILE ,O_LARGEFILE , }, +#if defined(O_DIRECT) + {TARGET_O_DIRECT ,TARGET_O_DIRECT ,O_DIRECT ,O_DIRECT , }, +#endif + {0 ,0 ,0 ,0 } +}; + +#define COPY_UTSNAME_FIELD (dest, src) \ + do { \ +/* __NEW_UTS_LEN doesn't include terminating null */ \ + (void )strncpy ((dest), (src), __NEW_UTS_LEN); \ + (dest)[__NEW_UTS_LEN] ='\0' ; \ + }while (0 ) + +static int sys_uname(struct new_utsname *buf) +{ +struct utsname uts_buf; + +if (uname (&uts_buf) <0 ) +return (-1 ); + +/* +* Just in case these have some differences, we +* translate utsname to new_utsname (which is the +* struct linux kernel uses). +*/ + +bzero (buf,sizeof (*buf)); +COPY_UTSNAME_FIELD (buf->sysname, uts_buf.sysname); +COPY_UTSNAME_FIELD (buf->nodename, uts_buf.nodename); +COPY_UTSNAME_FIELD (buf->release, uts_buf.release); +COPY_UTSNAME_FIELD (buf->version, uts_buf.version); +COPY_UTSNAME_FIELD (buf->machine, uts_buf.machine); +#ifdef _GNU_SOURCE +COPY_UTSNAME_FIELD (buf->domainname, uts_buf.domainname); +#endif +return (0 ); + +#undef COPY_UTSNAME_FIELD +} + +static int sys_getcwd1 (char *buf,size_t size) +{ +if (getcwd (buf, size) ==NULL ) { +/* getcwd() sets errno */ +return (-1 ); + } +return (0 ); +} + +#ifdef CONFIG_ATFILE +/* +* Host system seems to have atfile syscall stubs available. We +* now enable them one by one as specified by target syscall_nr.h. +*/ + +#ifdef TARGET_NR_faccessat +static int sys_faccessat (int dirfd,const char *pathname,int mode,int flags) +{ +return (faccessat (dirfd, pathname, mode, flags)); +} +#endif +#ifdef TARGET_NR_fchmodat +static int sys_fchmodat (int dirfd,const char *pathname,mode_t mode,int flags) +{ +return (fchmodat (dirfd, pathname, mode, flags)); +} +#endif +#ifdef TARGET_NR_fchownat +static int sys_fchownat (int dirfd,const char *pathname,uid_t owner, +gid_t group,int flags) +{ +return (fchownat (dirfd, pathname, owner, group, flags)); +} +#endif +#ifdef __NR_fstatat64 +static int sys_fstatat64 (int dirfd,const char *pathname,struct stat *buf, +int flags) +{ +return (fstatat (dirfd, pathname, buf, flags)); +} +#endif +#ifdef __NR_newfstatat +static int sys_newfstatat (int dirfd,const char *pathname,struct stat *buf, +int flags) +{ +return (fstatat (dirfd, pathname, buf, flags)); +} +#endif +#ifdef TARGET_NR_futimesat +static int sys_futimesat (int dirfd,const char *pathname, +const struct timeval times[2 ]) +{ +return (futimesat (dirfd, pathname, times)); +} +#endif +#ifdef TARGET_NR_linkat +static int sys_linkat (int olddirfd,const char *oldpath, +int newdirfd,const char *newpath,int flags) +{ +return (linkat (olddirfd, oldpath, newdirfd, newpath, flags)); +} +#endif +#ifdef TARGET_NR_mkdirat +static int sys_mkdirat (int dirfd,const char *pathname,mode_t mode) +{ +return (mkdirat (dirfd, pathname, mode)); +} +#endif +#ifdef TARGET_NR_mknodat +static int sys_mknodat (int dirfd,const char *pathname,mode_t mode, +dev_t dev) +{ +return (mknodat (dirfd, pathname, mode, dev)); +} +#endif +#ifdef TARGET_NR_openat +static int sys_openat (int dirfd,const char *pathname,int flags, ...) +{ +/* +* open(2) has extra parameter 'mode' when called with +* flag O_CREAT. +*/ +if ((flags &O_CREAT ) !=0 ) { +va_list ap; +mode_t mode; + +/* +* Get the 'mode' parameter and translate it to +* host bits. +*/ +va_start (ap, flags); + mode =va_arg (ap, mode_t); + mode =target_to_host_bitmask (mode, fcntl_flags_tbl); +va_end (ap); + +return (openat (dirfd, pathname, flags, mode)); + } +return (openat (dirfd, pathname, flags)); +} +#endif +#ifdef TARGET_NR_readlinkat +static int sys_readlinkat (int dirfd,const char *pathname,char *buf,size_t bufsiz) +{ +return (readlinkat (dirfd, pathname, buf, bufsiz)); +} +#endif +#ifdef TARGET_NR_renameat +static int sys_renameat (int olddirfd,const char *oldpath, +int newdirfd,const char *newpath) +{ +return (renameat (olddirfd, oldpath, newdirfd, newpath)); +} +#endif +#ifdef TARGET_NR_symlinkat +static int sys_symlinkat (const char *oldpath,int newdirfd,const char *newpath) +{ +return (symlinkat (oldpath, newdirfd, newpath)); +} +#endif +#ifdef TARGET_NR_unlinkat +static int sys_unlinkat (int dirfd,const char *pathname,int flags) +{ +return (unlinkat (dirfd, pathname, flags)); +} +#endif +#ifdef TARGET_NR_utimensat +static int sys_utimensat (int dirfd,const char *pathname, +const struct timespec times[2 ],int flags) +{ +return (utimensat (dirfd, pathname, times, flags)); +} +#endif +#else /* !CONFIG_ATFILE */ + +/* +* Try direct syscalls instead +*/ #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat) _syscall4(int,sys_faccessat,int,dirfd,const char *,pathname,int,mode,int,flags)#endif @@ -221,21 +444,14 @@ _syscall4(int,sys_fstatat64,int,dirfd,const char *,pathname, _syscall3(int,sys_futimesat,int,dirfd,const char *,pathname, const struct timeval *,times)#endif -_syscall2(int,sys_getcwd1,char *,buf,size_t,size) -#if TARGET_ABI_BITS ==32 -_syscall3(int, sys_getdents, uint, fd, struct linux_dirent *, dirp, uint, count); -#endif -#if defined(TARGET_NR_getdents64) && defined(__NR_getdents64) -_syscall3(int, sys_getdents64, uint, fd, struct linux_dirent64 *, dirp, uint, count); -#endif -_syscall2 (int, sys_getpriority, int, which, int, who); -#if !defined (__x86_64__) -_syscall5 (int, _llseek, uint, fd, ulong, hi, ulong, lo, - loff_t *, res, uint, wh); +#if (defined(TARGET_NR_newfstatat) || defined(TARGET_NR_fstatat64) ) && \ + defined(__NR_newfstatat) +_syscall4(int,sys_newfstatat,int,dirfd,const char *,pathname, + struct stat *,buf,int,flags)#endif #if defined(TARGET_NR_linkat) && defined(__NR_linkat) _syscall5(int,sys_linkat,int,olddirfd,const char *,oldpath, - int,newdirfd,const char *,newpath,int,flags) + int,newdirfd,const char *,newpath,int,flags)#endif #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat) _syscall3(int,sys_mkdirat,int,dirfd,const char *,pathname,mode_t,mode)@@ -244,11 +460,6 @@ _syscall3(int,sys_mkdirat,int,dirfd,const char *,pathname,mode_t,mode) _syscall4(int,sys_mknodat,int,dirfd,const char *,pathname, mode_t,mode,dev_t,dev)#endif -#if (defined(TARGET_NR_newfstatat) || defined(TARGET_NR_fstatat64) ) && \ - defined(__NR_newfstatat) -_syscall4(int,sys_newfstatat,int,dirfd,const char *,pathname, - struct stat *,buf,int,flags) -#endif #if defined(TARGET_NR_openat) && defined(__NR_openat) _syscall4(int,sys_openat,int,dirfd,const char *,pathname,int,flags,mode_t,mode)#endif @@ -260,24 +471,10 @@ _syscall4(int,sys_readlinkat,int,dirfd,const char *,pathname, _syscall4(int,sys_renameat,int,olddirfd,const char *,oldpath, int,newdirfd,const char *,newpath)#endif -_syscall3(int,sys_rt_sigqueueinfo,int,pid,int,sig,siginfo_t *,uinfo)#if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat) _syscall3(int,sys_symlinkat,const char *,oldpath, int,newdirfd,const char *,newpath)#endif -_syscall3(int,sys_syslog,int,type,char*,bufp,int,len) -#if defined(TARGET_NR_tgkill) && defined(__NR_tgkill) -_syscall3(int,sys_tgkill,int,tgid,int,pid,int,sig) -#endif -#if defined(TARGET_NR_tkill) && defined(__NR_tkill) -_syscall2(int,sys_tkill,int,tid,int,sig) -#endif -#ifdef __NR_exit_group -_syscall1(int,exit_group,int,error_code) -#endif -#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address) -_syscall1(int,set_tid_address,int *,tidptr) -#endif #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat) _syscall3(int,sys_unlinkat,int,dirfd,const char *,pathname,int,flags)#endif @@ -285,21 +482,36 @@ _syscall3(int,sys_unlinkat,int,dirfd,const char *,pathname,int,flags) _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname, const struct timespec *,tsp,int,flags)#endif + +#endif /* CONFIG_ATFILE */ + +#ifdef CONFIG_INOTIFY +#if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init) -_syscall0(int,sys_inotify_init) +static int sys_inotify_init (void ) +{ +return (inotify_init ()); +}#endif #if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch) -_syscall3(int,sys_inotify_add_watch,int,fd,const char *,pathname,uint32_t,mask) +static int sys_inotify_add_watch (int fd,const char *pathname,int32_t mask) +{ +return (inotify_add_watch (fd, pathname, mask)); +}#endif #if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch) -_syscall2(int,sys_inotify_rm_watch,int,fd,uint32_t,wd) -#endif -#if defined(USE_NPTL ) -#if defined(TARGET_NR_futex) && defined(__NR_futex) -_syscall6(int,sys_futex,int *,uaddr,int,op,int,val, - const struct timespec *,timeout,int *,uaddr2,int,val3) -#endif +static int sys_inotify_rm_watch (int fd,int32_t wd) +{ +return (inotify_rm_watch (fd,pathname, wd)); +}#endif +#else +/* Userspace can usually survive runtime without inotify */ +#undef TARGET_NR_inotify_init +#undef TARGET_NR_inotify_add_watch +#undef TARGET_NR_inotify_rm_watch +#endif /* CONFIG_INOTIFY */ +extern int personality (int );extern int flock (int ,int );@@ -2837,26 +3049,6 @@ static bitmask_transtbl mmap_flags_tbl[] = { { 0, 0, 0, 0 } }; -static bitmask_transtbl fcntl_flags_tbl[] = { - {TARGET_O_ACCMODE ,TARGET_O_WRONLY ,O_ACCMODE ,O_WRONLY , }, - {TARGET_O_ACCMODE ,TARGET_O_RDWR ,O_ACCMODE ,O_RDWR , }, - {TARGET_O_CREAT ,TARGET_O_CREAT ,O_CREAT ,O_CREAT , }, - {TARGET_O_EXCL ,TARGET_O_EXCL ,O_EXCL ,O_EXCL , }, - {TARGET_O_NOCTTY ,TARGET_O_NOCTTY ,O_NOCTTY ,O_NOCTTY , }, - {TARGET_O_TRUNC ,TARGET_O_TRUNC ,O_TRUNC ,O_TRUNC , }, - {TARGET_O_APPEND ,TARGET_O_APPEND ,O_APPEND ,O_APPEND , }, - {TARGET_O_NONBLOCK ,TARGET_O_NONBLOCK ,O_NONBLOCK ,O_NONBLOCK , }, - {TARGET_O_SYNC ,TARGET_O_SYNC ,O_SYNC ,O_SYNC , }, - {TARGET_FASYNC ,TARGET_FASYNC ,FASYNC ,FASYNC , }, - {TARGET_O_DIRECTORY ,TARGET_O_DIRECTORY ,O_DIRECTORY ,O_DIRECTORY , }, - {TARGET_O_NOFOLLOW ,TARGET_O_NOFOLLOW ,O_NOFOLLOW ,O_NOFOLLOW , }, - {TARGET_O_LARGEFILE ,TARGET_O_LARGEFILE ,O_LARGEFILE ,O_LARGEFILE , }, -#if defined(O_DIRECT) - {TARGET_O_DIRECT ,TARGET_O_DIRECT ,O_DIRECT ,O_DIRECT , }, -#endif - {0 ,0 ,0 ,0 } -}; -#if defined(TARGET_I386 )/* NOTE: there is really one LDT for all the threads */ Signature · 1 line
1.6.2.1
Signature · 2 lines
Aurelien Jarno GPG: 1024D/F1BCDB73 [email protected] http://www.aurel32.net
PATCH 10/10 linux-user: Proper exit code for uncaught signals
In reply to [email protected]From: Riku Voipio <[email protected]>
The proper exit code for dieing from an uncaught signal is -<signal>. The kernel doesn't allow exit() or _exit() to pass a negative value. To get the proper exit code we need to actually die from an uncaught signal.
A default signal handler is installed, we send ourself a signal and we wait for it to arrive.
Patch originates from Scratchbox
--- linux-user/signal.c | 37 +++++++++++++++++++++++++------------ 1 files changed, 25 insertions(+), 12 deletions(-)
linux-user/signal.c +25 -12
@@ -25,6 +25,7 @@#include <unistd.h> #include <signal.h> #include <errno.h> +#include <assert.h> #include <sys/ucontext.h> #include "qemu.h"
@@ -352,22 +353,34 @@ static inline void free_sigqueue(CPUState *env, struct sigqueue *q) static void QEMU_NORETURN force_sig(int sig) {int host_sig; +struct sigaction act; host_sig =target_to_host_signal (sig);fprintf (stderr,"qemu: uncaught target signal %d (%s) - exiting\n" , sig,strsignal (host_sig)); -#if 1 gdb_signalled (thread_env, sig); -_exit (-host_sig); -#else - { -struct sigaction act; -sigemptyset (&act.sa_mask); - act.sa_flags =SA_SIGINFO ; - act.sa_sigaction =SIG_DFL ; -sigaction (SIGABRT , &act,NULL ); -abort (); - } -#endif + +/* The proper exit code for dieing from an uncaught signal is +* -<signal>. The kernel doesn't allow exit() or _exit() to pass +* a negative value. To get the proper exit code we need to +* actually die from an uncaught signal. Here the default signal +* handler is installed, we send ourself a signal and we wait for +* it to arrive. */ +sigfillset (&act.sa_mask); + act.sa_handler =SIG_DFL ; +sigaction (host_sig, &act,NULL ); + +/* For some reason raise(host_sig) doesn't send the signal when +* statically linked on x86-64. */ +kill (getpid (), host_sig); + +/* Make sure the signal isn't masked (just reuse the mask inside +of act) */ +sigdelset (&act.sa_mask, host_sig); +sigsuspend (&act.sa_mask); + +/* unreachable */ +assert (0 ); + }/* queue a signal so that it will be send to the virtual CPU as soon
Signature · 1 line
1.6.2.1
Aurelien Jarno
AppliedRe: [Qemu-devel] [PATCH 10/10] linux-user: Proper exit code for uncaught signals
Quoted 9 lines · On Sun, Apr 05, 2009 at 11:59:26PM +0300, [email protected] wrote:
From: Riku Voipio <[email protected]>
The proper exit code for dieing from an uncaught signal is -<signal>. The kernel doesn't allow
exit()or_exit()to pass a negative value. To get the proper exit code we need to actually die from an uncaught signal.A default signal handler is installed, we send ourself a signal and we wait for it to arrive.
Quoted 6 lines
Patch originates from Scratchbox
Signed-off-by Riku Voipio <[email protected]>--- linux-user/signal.c | 37 +++++++++++++++++++++++++------------ 1 files changed, 25 insertions(+), 12 deletions(-)
Thanks, applied.
Quoted 65 lines
linux-user/signal.c +25
-12@@ -25,6 +25,7 @@#include <unistd.h> #include <signal.h> #include <errno.h> +#include <assert.h> #include <sys/ucontext.h> #include "qemu.h" @@ -352,22 +353,34 @@ static inline void free_sigqueue(CPUState *env, struct sigqueue *q) static void QEMU_NORETURN force_sig(int sig) {int host_sig; +struct sigaction act; host_sig =target_to_host_signal (sig);fprintf (stderr,"qemu: uncaught target signal %d (%s) - exiting\n" , sig,strsignal (host_sig)); -#if 1 gdb_signalled (thread_env, sig); -_exit (-host_sig); -#else - { -struct sigaction act; -sigemptyset (&act.sa_mask); - act.sa_flags =SA_SIGINFO ; - act.sa_sigaction =SIG_DFL ; -sigaction (SIGABRT , &act,NULL ); -abort (); - } -#endif + +/* The proper exit code for dieing from an uncaught signal is +* -<signal>. The kernel doesn't allow exit() or _exit() to pass +* a negative value. To get the proper exit code we need to +* actually die from an uncaught signal. Here the default signal +* handler is installed, we send ourself a signal and we wait for +* it to arrive. */ +sigfillset (&act.sa_mask); + act.sa_handler =SIG_DFL ; +sigaction (host_sig, &act,NULL ); + +/* For some reason raise(host_sig) doesn't send the signal when +* statically linked on x86-64. */ +kill (getpid (), host_sig); + +/* Make sure the signal isn't masked (just reuse the mask inside +of act) */ +sigdelset (&act.sa_mask, host_sig); +sigsuspend (&act.sa_mask); + +/* unreachable */ +assert (0 ); + }/* queue a signal so that it will be send to the virtual CPU as soon Signature · 1 line
1.6.2.1
Signature · 2 lines
Aurelien Jarno GPG: 1024D/F1BCDB73 [email protected] http://www.aurel32.net