Re: [Qemu-devel] [PATCH] linux-user: Implement capget, capset

[Riku Voipio]

On Fri, Mar 14, 2014 at 06:10:50PM +0000, Peter Maydell wrote:
> Implement the capget and capset syscalls. This is useful because
> simple programs like 'ls' try to use it in AArch64

I'm not seing this with ubuntu trusty, wookeys debian or my
static busybox. Where is your ls from? Also, runnning qemu-linux
user as root? How very brave :)

> , and otherwise
> we emit a lot of noise about it being unimplemented.

Well, it seems gcc 4.8 isn't smart enough for this patch:

linux-user/syscall.c: In function ‘do_syscall’:
linux-user/syscall.c:7739:46: error: ‘target_data’ may be used
uninitialized in this function [-Werror=maybe-uninitialized]
   target_data[i].effective = tswap32(data[i].effective);
                            ^
> Signed-off-by: Peter Maydell <address@hidden>
> ---
> Bugfix or feature? You decide :-)

perhaps unimplemented_nowarn for now and a proper implementation for 2.1 ?

Riku

>  linux-user/syscall.c      | 71 
> +++++++++++++++++++++++++++++++++++++++++++++--
>  linux-user/syscall_defs.h | 11 ++++++++
>  2 files changed, 80 insertions(+), 2 deletions(-)
> 
> diff --git a/linux-user/syscall.c b/linux-user/syscall.c
> index 2a8b66c..53c3d69 100644
> --- a/linux-user/syscall.c
> +++ b/linux-user/syscall.c
> @@ -43,6 +43,7 @@
>  #include <sys/resource.h>
>  #include <sys/mman.h>
>  #include <sys/swap.h>
> +#include <sys/capability.h>

This is from libcap-dev, which might not be installed by default. The
actual capset/capget functions seems to be in libc.

>  #include <signal.h>
>  #include <sched.h>
>  #ifdef __ia64__
> @@ -7641,9 +7642,75 @@ abi_long do_syscall(void *cpu_env, int num, abi_long 
> arg1,
>          unlock_user(p, arg1, ret);
>          break;
>      case TARGET_NR_capget:
> -        goto unimplemented;
>      case TARGET_NR_capset:
> -        goto unimplemented;
> +    {
> +        struct target_user_cap_header *target_header;
> +        struct target_user_cap_data *target_data;
> +        struct __user_cap_header_struct header;
> +        struct __user_cap_data_struct data[2];
> +        struct __user_cap_data_struct *dataptr = NULL;
> +        int i, target_datalen;
> +        int data_items = 1;
> +
> +        if (!lock_user_struct(VERIFY_WRITE, target_header, arg1, 1)) {
> +            goto efault;
> +        }
> +        header.version = tswap32(target_header->version);
> +        header.pid = tswap32(target_header->pid);
> +
> +        if (header.version != _LINUX_CAPABILITY_VERSION_1) {
> +            /* Version 2 and up takes pointer to two user_data structs */
> +            data_items = 2;
> +        }
> +
> +        target_datalen = sizeof(*target_data) * data_items;
> +
> +        if (arg2) {
> +            if (num == TARGET_NR_capget) {
> +                target_data = lock_user(VERIFY_WRITE, arg2, target_datalen, 
> 0);
> +            } else {
> +                target_data = lock_user(VERIFY_READ, arg2, target_datalen, 
> 1);
> +            }
> +            if (!target_data) {
> +                unlock_user_struct(target_header, arg1, 0);
> +                goto efault;
> +            }
> +
> +            if (num == TARGET_NR_capset) {
> +                for (i = 0; i < data_items; i++) {
> +                    data[i].effective = tswap32(target_data[i].effective);
> +                    data[i].permitted = tswap32(target_data[i].permitted);
> +                    data[i].inheritable = 
> tswap32(target_data[i].inheritable);
> +                }
> +            }
> +
> +            dataptr = data;
> +        }
> +
> +        if (num == TARGET_NR_capget) {
> +            ret = get_errno(capget(&header, dataptr));
> +        } else {
> +            ret = get_errno(capset(&header, dataptr));
> +        }
> +
> +        /* The kernel always updates version for both capget and capset */
> +        target_header->version = tswap32(header.version);
> +        unlock_user_struct(target_header, arg1, 1);
> +
> +        if (arg2) {
> +            if (num == TARGET_NR_capget) {
> +                for (i = 0; i < data_items; i++) {
> +                    target_data[i].effective = tswap32(data[i].effective);
> +                    target_data[i].permitted = tswap32(data[i].permitted);
> +                    target_data[i].inheritable = 
> tswap32(data[i].inheritable);
> +                }
> +                unlock_user(target_data, arg2, target_datalen);
> +            } else {
> +                unlock_user(target_data, arg2, 0);
> +            }
> +        }
> +        break;
> +    }
>      case TARGET_NR_sigaltstack:
>  #if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
>      defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA) || 
> \
> diff --git a/linux-user/syscall_defs.h b/linux-user/syscall_defs.h
> index 732c9e3..7db878a 100644
> --- a/linux-user/syscall_defs.h
> +++ b/linux-user/syscall_defs.h
> @@ -2559,3 +2559,14 @@ struct target_sigevent {
>          } _sigev_thread;
>      } _sigev_un;
>  };
> +
> +struct target_user_cap_header {
> +    uint32_t version;
> +    int pid;
> +};
> +
> +struct target_user_cap_data {
> +    uint32_t effective;
> +    uint32_t permitted;
> +    uint32_t inheritable;
> +};
> -- 
> 1.9.0