* [PATCH v4 0/2] linux-user: fixes for sched_ syscalls @ 2022-01-05 4:18 Tonis Tiigi 2022-01-05 4:18 ` [PATCH v4 1/2] linux-user: add sched_getattr support Tonis Tiigi 2022-01-05 4:18 ` [PATCH v4 2/2] linux-user: call set/getscheduler set/getparam directly Tonis Tiigi 0 siblings, 2 replies; 7+ messages in thread From: Tonis Tiigi @ 2022-01-05 4:18 UTC (permalink / raw) To: qemu-devel; +Cc: Tonis Tiigi, laurent This patchset improves support for sched_* syscalls under user emulation. The first commit adds support for sched_g/setattr that was previously not implemented. These syscalls are not exposed by glibc. The struct type needs to be redefined as it can't be included directly before https://lkml.org/lkml/2020/5/28/810 . sched_attr type can grow in future kernel versions. When client sends values that QEMU does not understand it will return E2BIG with same semantics as old kernel would so client can retry with smaller inputs. The second commit fixes sched_g/setscheduler and sched_g/setparam, when QEMU is built with musl. Musl does not implement these due to conflict between what these functions should do in syscalls and libc https://git.musl-libc.org/cgit/musl/commit/?id=1e21e78bf7a5c24c217446d8760be7b7188711c2 . I've changed it to call syscall directly what should always be the expected behavior for the user. Via https://github.com/tonistiigi/binfmt/pull/70 https://github.com/tonistiigi/binfmt/pull/73 with additional tests. Changes v4->v3: - host `sched_param` type is used for local syscalls - Added check_zeroed_user() helper. This function takes kernel and userspace size and checks if the extra padding is empty with same rules as kernel does. I also tried with only one size parameter but doing all the `size-sizeof()` calculations on caller side made the function quite useless. - Defined local host version for `sched_param` so target and host types are defined separately. - Moved size type declaration to the beginning of the function. Changes v3->v2: - Fix wrong property name for sched_flags - Validate size parameter and handle E2BIG errors same way as kernel does. There is one case where it can't be done completely correctly but clients should still be able to handle it: when client sends a bigger non-zero structure than current kernel definition we will send E2BIG with the struct size known to qemu. If now the client sends structure with this size it may still get another E2BIG error from the kernel if kernel is old and doesn't implement util_min/util_max. I don't think this can be handled without making additional syscalls to kernel. Changes v1->v2: - Locking guest addresses for sched_attr is now based on size inputs, not local struct size. Also did the same for setter where I now read only the size field of the struct first. - Use offsetof() when checking if optional fields are supported. - `target_sched_attr` now uses aligned types as requested. I didn't quite understand why this is needed as I don't see same in kernel headers, but as this type uses only constant width fields and is already aligned by default it can't break anything. - Fixed formatting. - Defined own `target_sched_param` struct as requested. Tonis Tiigi (2): linux-user: add sched_getattr support linux-user: call set/getscheduler set/getparam directly linux-user/syscall.c | 157 +++++++++++++++++++++++++++++++++++--- linux-user/syscall_defs.h | 18 +++++ 2 files changed, 165 insertions(+), 10 deletions(-) -- 2.32.0 (Apple Git-132) ^ permalink raw reply [flat|nested] 7+ messages in thread
* [PATCH v4 1/2] linux-user: add sched_getattr support 2022-01-05 4:18 [PATCH v4 0/2] linux-user: fixes for sched_ syscalls Tonis Tiigi @ 2022-01-05 4:18 ` Tonis Tiigi 2022-01-05 10:14 ` Laurent Vivier 2022-01-05 10:16 ` Laurent Vivier 2022-01-05 4:18 ` [PATCH v4 2/2] linux-user: call set/getscheduler set/getparam directly Tonis Tiigi 1 sibling, 2 replies; 7+ messages in thread From: Tonis Tiigi @ 2022-01-05 4:18 UTC (permalink / raw) To: qemu-devel; +Cc: Tonis Tiigi, laurent These syscalls are not exposed by glibc. The struct type need to be redefined as it can't be included directly before https://lkml.org/lkml/2020/5/28/810 . sched_attr type can grow in future kernel versions. When client sends values that QEMU does not understand it will return E2BIG with same semantics as old kernel would so client can retry with smaller inputs. Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com> --- linux-user/syscall.c | 123 ++++++++++++++++++++++++++++++++++++++ linux-user/syscall_defs.h | 14 +++++ 2 files changed, 137 insertions(+) diff --git a/linux-user/syscall.c b/linux-user/syscall.c index 56a3e17183..1b8415c8a3 100644 --- a/linux-user/syscall.c +++ b/linux-user/syscall.c @@ -340,6 +340,25 @@ _syscall3(int, sys_sched_getaffinity, pid_t, pid, unsigned int, len, #define __NR_sys_sched_setaffinity __NR_sched_setaffinity _syscall3(int, sys_sched_setaffinity, pid_t, pid, unsigned int, len, unsigned long *, user_mask_ptr); +/* sched_attr is not defined in glibc */ +struct sched_attr { + uint32_t size; + uint32_t sched_policy; + uint64_t sched_flags; + int32_t sched_nice; + uint32_t sched_priority; + uint64_t sched_runtime; + uint64_t sched_deadline; + uint64_t sched_period; + uint32_t sched_util_min; + uint32_t sched_util_max; +}; +#define __NR_sys_sched_getattr __NR_sched_getattr +_syscall4(int, sys_sched_getattr, pid_t, pid, struct sched_attr *, attr, + unsigned int, size, unsigned int, flags); +#define __NR_sys_sched_setattr __NR_sched_setattr +_syscall3(int, sys_sched_setattr, pid_t, pid, struct sched_attr *, attr, + unsigned int, flags); #define __NR_sys_getcpu __NR_getcpu _syscall3(int, sys_getcpu, unsigned *, cpu, unsigned *, node, void *, tcache); _syscall4(int, reboot, int, magic1, int, magic2, unsigned int, cmd, @@ -558,6 +577,24 @@ const char *target_strerror(int err) return strerror(target_to_host_errno(err)); } +static int check_zeroed_user(abi_long addr, size_t ksize, size_t usize) +{ + int i; + uint8_t b; + if (usize <= ksize) { + return 1; + } + for (i = ksize; i < usize; i++) { + if (get_user_u8(b, addr + i)) { + return -TARGET_EFAULT; + } + if (b != 0) { + return 0; + } + } + return 1; +} + #define safe_syscall0(type, name) \ static type safe_##name(void) \ { \ @@ -10594,6 +10631,92 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1, } case TARGET_NR_sched_getscheduler: return get_errno(sched_getscheduler(arg1)); + case TARGET_NR_sched_getattr: + { + struct target_sched_attr *target_scha; + struct sched_attr scha; + if (arg2 == 0) { + return -TARGET_EINVAL; + } + if (arg3 > sizeof(scha)) { + arg3 = sizeof(scha); + } + ret = get_errno(sys_sched_getattr(arg1, &scha, arg3, arg4)); + if (!is_error(ret)) { + target_scha = lock_user(VERIFY_WRITE, arg2, arg3, 0); + if (!target_scha) { + return -TARGET_EFAULT; + } + target_scha->size = tswap32(scha.size); + target_scha->sched_policy = tswap32(scha.sched_policy); + target_scha->sched_flags = tswap64(scha.sched_flags); + target_scha->sched_nice = tswap32(scha.sched_nice); + target_scha->sched_priority = tswap32(scha.sched_priority); + target_scha->sched_runtime = tswap64(scha.sched_runtime); + target_scha->sched_deadline = tswap64(scha.sched_deadline); + target_scha->sched_period = tswap64(scha.sched_period); + if (scha.size > offsetof(struct sched_attr, sched_util_min)) { + target_scha->sched_util_min = tswap32(scha.sched_util_min); + target_scha->sched_util_max = tswap32(scha.sched_util_max); + } + unlock_user(target_scha, arg2, arg3); + } + return ret; + } + case TARGET_NR_sched_setattr: + { + struct target_sched_attr *target_scha; + struct sched_attr scha; + uint32_t size; + int zeroed; + if (arg2 == 0) { + return -TARGET_EINVAL; + } + if (get_user_u32(size, arg2)) { + return -TARGET_EFAULT; + } + if (!size) { + size = offsetof(struct target_sched_attr, sched_util_min); + } + if (size < offsetof(struct target_sched_attr, sched_util_min)) { + if (put_user_u32(sizeof(struct target_sched_attr), arg2)) { + return -TARGET_EFAULT; + } + return -TARGET_E2BIG; + } + + zeroed = check_zeroed_user(arg2, sizeof(struct target_sched_attr), size); + if (zeroed < 0) { + return zeroed; + } else if (zeroed == 0) { + if (put_user_u32(sizeof(struct target_sched_attr), arg2)) { + return -TARGET_EFAULT; + } + return -TARGET_E2BIG; + } + if (size > sizeof(struct target_sched_attr)) { + size = sizeof(struct target_sched_attr); + } + + target_scha = lock_user(VERIFY_READ, arg2, size, 1); + if (!target_scha) { + return -TARGET_EFAULT; + } + scha.size = size; + scha.sched_policy = tswap32(target_scha->sched_policy); + scha.sched_flags = tswap64(target_scha->sched_flags); + scha.sched_nice = tswap32(target_scha->sched_nice); + scha.sched_priority = tswap32(target_scha->sched_priority); + scha.sched_runtime = tswap64(target_scha->sched_runtime); + scha.sched_deadline = tswap64(target_scha->sched_deadline); + scha.sched_period = tswap64(target_scha->sched_period); + if (size > offsetof(struct target_sched_attr, sched_util_min)) { + scha.sched_util_min = tswap32(target_scha->sched_util_min); + scha.sched_util_max = tswap32(target_scha->sched_util_max); + } + unlock_user(target_scha, arg2, 0); + return get_errno(sys_sched_setattr(arg1, &scha, arg3)); + } case TARGET_NR_sched_yield: return get_errno(sched_yield()); case TARGET_NR_sched_get_priority_max: diff --git a/linux-user/syscall_defs.h b/linux-user/syscall_defs.h index 0b13975937..310d6ce8ad 100644 --- a/linux-user/syscall_defs.h +++ b/linux-user/syscall_defs.h @@ -2914,4 +2914,18 @@ struct target_statx { /* 0x100 */ }; +/* from kernel's include/linux/sched/types.h */ +struct target_sched_attr { + abi_uint size; + abi_uint sched_policy; + abi_ullong sched_flags; + abi_int sched_nice; + abi_uint sched_priority; + abi_ullong sched_runtime; + abi_ullong sched_deadline; + abi_ullong sched_period; + abi_uint sched_util_min; + abi_uint sched_util_max; +}; + #endif -- 2.32.0 (Apple Git-132) ^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [PATCH v4 1/2] linux-user: add sched_getattr support 2022-01-05 4:18 ` [PATCH v4 1/2] linux-user: add sched_getattr support Tonis Tiigi @ 2022-01-05 10:14 ` Laurent Vivier 2022-01-05 10:16 ` Laurent Vivier 1 sibling, 0 replies; 7+ messages in thread From: Laurent Vivier @ 2022-01-05 10:14 UTC (permalink / raw) To: Tonis Tiigi, qemu-devel Le 05/01/2022 à 05:18, Tonis Tiigi a écrit : > These syscalls are not exposed by glibc. The struct type need to be > redefined as it can't be included directly before > https://lkml.org/lkml/2020/5/28/810 . > > sched_attr type can grow in future kernel versions. When client sends > values that QEMU does not understand it will return E2BIG with same > semantics as old kernel would so client can retry with smaller inputs. > > Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com> > --- > linux-user/syscall.c | 123 ++++++++++++++++++++++++++++++++++++++ > linux-user/syscall_defs.h | 14 +++++ > 2 files changed, 137 insertions(+) > > diff --git a/linux-user/syscall.c b/linux-user/syscall.c > index 56a3e17183..1b8415c8a3 100644 > --- a/linux-user/syscall.c > +++ b/linux-user/syscall.c > @@ -340,6 +340,25 @@ _syscall3(int, sys_sched_getaffinity, pid_t, pid, unsigned int, len, > #define __NR_sys_sched_setaffinity __NR_sched_setaffinity > _syscall3(int, sys_sched_setaffinity, pid_t, pid, unsigned int, len, > unsigned long *, user_mask_ptr); > +/* sched_attr is not defined in glibc */ > +struct sched_attr { > + uint32_t size; > + uint32_t sched_policy; > + uint64_t sched_flags; > + int32_t sched_nice; > + uint32_t sched_priority; > + uint64_t sched_runtime; > + uint64_t sched_deadline; > + uint64_t sched_period; > + uint32_t sched_util_min; > + uint32_t sched_util_max; > +}; > +#define __NR_sys_sched_getattr __NR_sched_getattr > +_syscall4(int, sys_sched_getattr, pid_t, pid, struct sched_attr *, attr, > + unsigned int, size, unsigned int, flags); > +#define __NR_sys_sched_setattr __NR_sched_setattr > +_syscall3(int, sys_sched_setattr, pid_t, pid, struct sched_attr *, attr, > + unsigned int, flags); > #define __NR_sys_getcpu __NR_getcpu > _syscall3(int, sys_getcpu, unsigned *, cpu, unsigned *, node, void *, tcache); > _syscall4(int, reboot, int, magic1, int, magic2, unsigned int, cmd, > @@ -558,6 +577,24 @@ const char *target_strerror(int err) > return strerror(target_to_host_errno(err)); > } > > +static int check_zeroed_user(abi_long addr, size_t ksize, size_t usize) > +{ > + int i; > + uint8_t b; > + if (usize <= ksize) { > + return 1; > + } > + for (i = ksize; i < usize; i++) { > + if (get_user_u8(b, addr + i)) { > + return -TARGET_EFAULT; > + } > + if (b != 0) { > + return 0; > + } > + } > + return 1; > +} > + > #define safe_syscall0(type, name) \ > static type safe_##name(void) \ > { \ > @@ -10594,6 +10631,92 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1, > } > case TARGET_NR_sched_getscheduler: > return get_errno(sched_getscheduler(arg1)); > + case TARGET_NR_sched_getattr: > + { > + struct target_sched_attr *target_scha; > + struct sched_attr scha; > + if (arg2 == 0) { > + return -TARGET_EINVAL; > + } > + if (arg3 > sizeof(scha)) { > + arg3 = sizeof(scha); > + } > + ret = get_errno(sys_sched_getattr(arg1, &scha, arg3, arg4)); > + if (!is_error(ret)) { > + target_scha = lock_user(VERIFY_WRITE, arg2, arg3, 0); > + if (!target_scha) { > + return -TARGET_EFAULT; > + } > + target_scha->size = tswap32(scha.size); > + target_scha->sched_policy = tswap32(scha.sched_policy); > + target_scha->sched_flags = tswap64(scha.sched_flags); > + target_scha->sched_nice = tswap32(scha.sched_nice); > + target_scha->sched_priority = tswap32(scha.sched_priority); > + target_scha->sched_runtime = tswap64(scha.sched_runtime); > + target_scha->sched_deadline = tswap64(scha.sched_deadline); > + target_scha->sched_period = tswap64(scha.sched_period); > + if (scha.size > offsetof(struct sched_attr, sched_util_min)) { > + target_scha->sched_util_min = tswap32(scha.sched_util_min); > + target_scha->sched_util_max = tswap32(scha.sched_util_max); > + } > + unlock_user(target_scha, arg2, arg3); > + } > + return ret; > + } > + case TARGET_NR_sched_setattr: > + { > + struct target_sched_attr *target_scha; > + struct sched_attr scha; > + uint32_t size; > + int zeroed; > + if (arg2 == 0) { > + return -TARGET_EINVAL; > + } > + if (get_user_u32(size, arg2)) { > + return -TARGET_EFAULT; > + } > + if (!size) { > + size = offsetof(struct target_sched_attr, sched_util_min); > + } > + if (size < offsetof(struct target_sched_attr, sched_util_min)) { > + if (put_user_u32(sizeof(struct target_sched_attr), arg2)) { > + return -TARGET_EFAULT; > + } > + return -TARGET_E2BIG; > + } > + > + zeroed = check_zeroed_user(arg2, sizeof(struct target_sched_attr), size); > + if (zeroed < 0) { > + return zeroed; > + } else if (zeroed == 0) { > + if (put_user_u32(sizeof(struct target_sched_attr), arg2)) { > + return -TARGET_EFAULT; > + } > + return -TARGET_E2BIG; > + } > + if (size > sizeof(struct target_sched_attr)) { > + size = sizeof(struct target_sched_attr); > + } > + > + target_scha = lock_user(VERIFY_READ, arg2, size, 1); > + if (!target_scha) { > + return -TARGET_EFAULT; > + } > + scha.size = size; > + scha.sched_policy = tswap32(target_scha->sched_policy); > + scha.sched_flags = tswap64(target_scha->sched_flags); > + scha.sched_nice = tswap32(target_scha->sched_nice); > + scha.sched_priority = tswap32(target_scha->sched_priority); > + scha.sched_runtime = tswap64(target_scha->sched_runtime); > + scha.sched_deadline = tswap64(target_scha->sched_deadline); > + scha.sched_period = tswap64(target_scha->sched_period); > + if (size > offsetof(struct target_sched_attr, sched_util_min)) { > + scha.sched_util_min = tswap32(target_scha->sched_util_min); > + scha.sched_util_max = tswap32(target_scha->sched_util_max); > + } > + unlock_user(target_scha, arg2, 0); > + return get_errno(sys_sched_setattr(arg1, &scha, arg3)); > + } > case TARGET_NR_sched_yield: > return get_errno(sched_yield()); > case TARGET_NR_sched_get_priority_max: > diff --git a/linux-user/syscall_defs.h b/linux-user/syscall_defs.h > index 0b13975937..310d6ce8ad 100644 > --- a/linux-user/syscall_defs.h > +++ b/linux-user/syscall_defs.h > @@ -2914,4 +2914,18 @@ struct target_statx { > /* 0x100 */ > }; > > +/* from kernel's include/linux/sched/types.h */ > +struct target_sched_attr { > + abi_uint size; > + abi_uint sched_policy; > + abi_ullong sched_flags; > + abi_int sched_nice; > + abi_uint sched_priority; > + abi_ullong sched_runtime; > + abi_ullong sched_deadline; > + abi_ullong sched_period; > + abi_uint sched_util_min; > + abi_uint sched_util_max; > +}; > + > #endif Reviewed-by: Laurent Vivier <laurent@vivier.eu> ^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH v4 1/2] linux-user: add sched_getattr support 2022-01-05 4:18 ` [PATCH v4 1/2] linux-user: add sched_getattr support Tonis Tiigi 2022-01-05 10:14 ` Laurent Vivier @ 2022-01-05 10:16 ` Laurent Vivier 1 sibling, 0 replies; 7+ messages in thread From: Laurent Vivier @ 2022-01-05 10:16 UTC (permalink / raw) To: Tonis Tiigi, qemu-devel Le 05/01/2022 à 05:18, Tonis Tiigi a écrit : > These syscalls are not exposed by glibc. The struct type need to be > redefined as it can't be included directly before > https://lkml.org/lkml/2020/5/28/810 . > > sched_attr type can grow in future kernel versions. When client sends > values that QEMU does not understand it will return E2BIG with same > semantics as old kernel would so client can retry with smaller inputs. > > Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com> > --- > linux-user/syscall.c | 123 ++++++++++++++++++++++++++++++++++++++ > linux-user/syscall_defs.h | 14 +++++ > 2 files changed, 137 insertions(+) > > diff --git a/linux-user/syscall.c b/linux-user/syscall.c > index 56a3e17183..1b8415c8a3 100644 > --- a/linux-user/syscall.c > +++ b/linux-user/syscall.c > @@ -340,6 +340,25 @@ _syscall3(int, sys_sched_getaffinity, pid_t, pid, unsigned int, len, > #define __NR_sys_sched_setaffinity __NR_sched_setaffinity > _syscall3(int, sys_sched_setaffinity, pid_t, pid, unsigned int, len, > unsigned long *, user_mask_ptr); > +/* sched_attr is not defined in glibc */ > +struct sched_attr { > + uint32_t size; > + uint32_t sched_policy; > + uint64_t sched_flags; > + int32_t sched_nice; > + uint32_t sched_priority; > + uint64_t sched_runtime; > + uint64_t sched_deadline; > + uint64_t sched_period; > + uint32_t sched_util_min; > + uint32_t sched_util_max; > +}; > +#define __NR_sys_sched_getattr __NR_sched_getattr > +_syscall4(int, sys_sched_getattr, pid_t, pid, struct sched_attr *, attr, > + unsigned int, size, unsigned int, flags); > +#define __NR_sys_sched_setattr __NR_sched_setattr > +_syscall3(int, sys_sched_setattr, pid_t, pid, struct sched_attr *, attr, > + unsigned int, flags); > #define __NR_sys_getcpu __NR_getcpu > _syscall3(int, sys_getcpu, unsigned *, cpu, unsigned *, node, void *, tcache); > _syscall4(int, reboot, int, magic1, int, magic2, unsigned int, cmd, > @@ -558,6 +577,24 @@ const char *target_strerror(int err) > return strerror(target_to_host_errno(err)); > } > > +static int check_zeroed_user(abi_long addr, size_t ksize, size_t usize) > +{ > + int i; > + uint8_t b; > + if (usize <= ksize) { > + return 1; > + } > + for (i = ksize; i < usize; i++) { > + if (get_user_u8(b, addr + i)) { > + return -TARGET_EFAULT; > + } > + if (b != 0) { > + return 0; > + } > + } > + return 1; > +} > + > #define safe_syscall0(type, name) \ > static type safe_##name(void) \ > { \ > @@ -10594,6 +10631,92 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1, > } > case TARGET_NR_sched_getscheduler: > return get_errno(sched_getscheduler(arg1)); > + case TARGET_NR_sched_getattr: > + { > + struct target_sched_attr *target_scha; > + struct sched_attr scha; > + if (arg2 == 0) { > + return -TARGET_EINVAL; > + } > + if (arg3 > sizeof(scha)) { > + arg3 = sizeof(scha); > + } > + ret = get_errno(sys_sched_getattr(arg1, &scha, arg3, arg4)); > + if (!is_error(ret)) { > + target_scha = lock_user(VERIFY_WRITE, arg2, arg3, 0); > + if (!target_scha) { > + return -TARGET_EFAULT; > + } > + target_scha->size = tswap32(scha.size); > + target_scha->sched_policy = tswap32(scha.sched_policy); > + target_scha->sched_flags = tswap64(scha.sched_flags); > + target_scha->sched_nice = tswap32(scha.sched_nice); > + target_scha->sched_priority = tswap32(scha.sched_priority); > + target_scha->sched_runtime = tswap64(scha.sched_runtime); > + target_scha->sched_deadline = tswap64(scha.sched_deadline); > + target_scha->sched_period = tswap64(scha.sched_period); > + if (scha.size > offsetof(struct sched_attr, sched_util_min)) { > + target_scha->sched_util_min = tswap32(scha.sched_util_min); > + target_scha->sched_util_max = tswap32(scha.sched_util_max); > + } > + unlock_user(target_scha, arg2, arg3); > + } > + return ret; > + } > + case TARGET_NR_sched_setattr: > + { > + struct target_sched_attr *target_scha; > + struct sched_attr scha; > + uint32_t size; > + int zeroed; > + if (arg2 == 0) { > + return -TARGET_EINVAL; > + } > + if (get_user_u32(size, arg2)) { > + return -TARGET_EFAULT; > + } > + if (!size) { > + size = offsetof(struct target_sched_attr, sched_util_min); > + } > + if (size < offsetof(struct target_sched_attr, sched_util_min)) { > + if (put_user_u32(sizeof(struct target_sched_attr), arg2)) { > + return -TARGET_EFAULT; > + } > + return -TARGET_E2BIG; > + } > + > + zeroed = check_zeroed_user(arg2, sizeof(struct target_sched_attr), size); > + if (zeroed < 0) { > + return zeroed; > + } else if (zeroed == 0) { > + if (put_user_u32(sizeof(struct target_sched_attr), arg2)) { > + return -TARGET_EFAULT; > + } > + return -TARGET_E2BIG; > + } > + if (size > sizeof(struct target_sched_attr)) { > + size = sizeof(struct target_sched_attr); > + } > + > + target_scha = lock_user(VERIFY_READ, arg2, size, 1); > + if (!target_scha) { > + return -TARGET_EFAULT; > + } > + scha.size = size; > + scha.sched_policy = tswap32(target_scha->sched_policy); > + scha.sched_flags = tswap64(target_scha->sched_flags); > + scha.sched_nice = tswap32(target_scha->sched_nice); > + scha.sched_priority = tswap32(target_scha->sched_priority); > + scha.sched_runtime = tswap64(target_scha->sched_runtime); > + scha.sched_deadline = tswap64(target_scha->sched_deadline); > + scha.sched_period = tswap64(target_scha->sched_period); > + if (size > offsetof(struct target_sched_attr, sched_util_min)) { > + scha.sched_util_min = tswap32(target_scha->sched_util_min); > + scha.sched_util_max = tswap32(target_scha->sched_util_max); > + } > + unlock_user(target_scha, arg2, 0); > + return get_errno(sys_sched_setattr(arg1, &scha, arg3)); > + } > case TARGET_NR_sched_yield: > return get_errno(sched_yield()); > case TARGET_NR_sched_get_priority_max: > diff --git a/linux-user/syscall_defs.h b/linux-user/syscall_defs.h > index 0b13975937..310d6ce8ad 100644 > --- a/linux-user/syscall_defs.h > +++ b/linux-user/syscall_defs.h > @@ -2914,4 +2914,18 @@ struct target_statx { > /* 0x100 */ > }; > > +/* from kernel's include/linux/sched/types.h */ > +struct target_sched_attr { > + abi_uint size; > + abi_uint sched_policy; > + abi_ullong sched_flags; > + abi_int sched_nice; > + abi_uint sched_priority; > + abi_ullong sched_runtime; > + abi_ullong sched_deadline; > + abi_ullong sched_period; > + abi_uint sched_util_min; > + abi_uint sched_util_max; > +}; > + > #endif Applied to my linux-user-for-7.0 branch. Thanks, Laurent ^ permalink raw reply [flat|nested] 7+ messages in thread
* [PATCH v4 2/2] linux-user: call set/getscheduler set/getparam directly 2022-01-05 4:18 [PATCH v4 0/2] linux-user: fixes for sched_ syscalls Tonis Tiigi 2022-01-05 4:18 ` [PATCH v4 1/2] linux-user: add sched_getattr support Tonis Tiigi @ 2022-01-05 4:18 ` Tonis Tiigi 2022-01-05 10:14 ` Laurent Vivier 2022-01-05 10:16 ` Laurent Vivier 1 sibling, 2 replies; 7+ messages in thread From: Tonis Tiigi @ 2022-01-05 4:18 UTC (permalink / raw) To: qemu-devel; +Cc: Tonis Tiigi, laurent There seems to be difference in syscall and libc definition of these methods and therefore musl does not implement them (1e21e78bf7). Call syscall directly to ensure the behavior of the libc of user application, not the libc that was used to build QEMU. Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com> --- linux-user/syscall.c | 34 ++++++++++++++++++++++++---------- linux-user/syscall_defs.h | 4 ++++ 2 files changed, 28 insertions(+), 10 deletions(-) diff --git a/linux-user/syscall.c b/linux-user/syscall.c index 1b8415c8a3..30962155a6 100644 --- a/linux-user/syscall.c +++ b/linux-user/syscall.c @@ -359,6 +359,17 @@ _syscall4(int, sys_sched_getattr, pid_t, pid, struct sched_attr *, attr, #define __NR_sys_sched_setattr __NR_sched_setattr _syscall3(int, sys_sched_setattr, pid_t, pid, struct sched_attr *, attr, unsigned int, flags); +#define __NR_sys_sched_getscheduler __NR_sched_getscheduler +_syscall1(int, sys_sched_getscheduler, pid_t, pid); +#define __NR_sys_sched_setscheduler __NR_sched_setscheduler +_syscall3(int, sys_sched_setscheduler, pid_t, pid, int, policy, + const struct sched_param *, param); +#define __NR_sys_sched_getparam __NR_sched_getparam +_syscall2(int, sys_sched_getparam, pid_t, pid, + struct sched_param *, param); +#define __NR_sys_sched_setparam __NR_sched_setparam +_syscall2(int, sys_sched_setparam, pid_t, pid, + const struct sched_param *, param); #define __NR_sys_getcpu __NR_getcpu _syscall3(int, sys_getcpu, unsigned *, cpu, unsigned *, node, void *, tcache); _syscall4(int, reboot, int, magic1, int, magic2, unsigned int, cmd, @@ -10587,30 +10598,32 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1, return ret; case TARGET_NR_sched_setparam: { - struct sched_param *target_schp; + struct target_sched_param *target_schp; struct sched_param schp; if (arg2 == 0) { return -TARGET_EINVAL; } - if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1)) + if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1)) { return -TARGET_EFAULT; + } schp.sched_priority = tswap32(target_schp->sched_priority); unlock_user_struct(target_schp, arg2, 0); - return get_errno(sched_setparam(arg1, &schp)); + return get_errno(sys_sched_setparam(arg1, &schp)); } case TARGET_NR_sched_getparam: { - struct sched_param *target_schp; + struct target_sched_param *target_schp; struct sched_param schp; if (arg2 == 0) { return -TARGET_EINVAL; } - ret = get_errno(sched_getparam(arg1, &schp)); + ret = get_errno(sys_sched_getparam(arg1, &schp)); if (!is_error(ret)) { - if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0)) + if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0)) { return -TARGET_EFAULT; + } target_schp->sched_priority = tswap32(schp.sched_priority); unlock_user_struct(target_schp, arg2, 1); } @@ -10618,19 +10631,20 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1, return ret; case TARGET_NR_sched_setscheduler: { - struct sched_param *target_schp; + struct target_sched_param *target_schp; struct sched_param schp; if (arg3 == 0) { return -TARGET_EINVAL; } - if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1)) + if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1)) { return -TARGET_EFAULT; + } schp.sched_priority = tswap32(target_schp->sched_priority); unlock_user_struct(target_schp, arg3, 0); - return get_errno(sched_setscheduler(arg1, arg2, &schp)); + return get_errno(sys_sched_setscheduler(arg1, arg2, &schp)); } case TARGET_NR_sched_getscheduler: - return get_errno(sched_getscheduler(arg1)); + return get_errno(sys_sched_getscheduler(arg1)); case TARGET_NR_sched_getattr: { struct target_sched_attr *target_scha; diff --git a/linux-user/syscall_defs.h b/linux-user/syscall_defs.h index 310d6ce8ad..28b9fe9a47 100644 --- a/linux-user/syscall_defs.h +++ b/linux-user/syscall_defs.h @@ -2928,4 +2928,8 @@ struct target_sched_attr { abi_uint sched_util_max; }; +struct target_sched_param { + abi_int sched_priority; +}; + #endif -- 2.32.0 (Apple Git-132) ^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [PATCH v4 2/2] linux-user: call set/getscheduler set/getparam directly 2022-01-05 4:18 ` [PATCH v4 2/2] linux-user: call set/getscheduler set/getparam directly Tonis Tiigi @ 2022-01-05 10:14 ` Laurent Vivier 2022-01-05 10:16 ` Laurent Vivier 1 sibling, 0 replies; 7+ messages in thread From: Laurent Vivier @ 2022-01-05 10:14 UTC (permalink / raw) To: Tonis Tiigi, qemu-devel Le 05/01/2022 à 05:18, Tonis Tiigi a écrit : > There seems to be difference in syscall and libc definition of these > methods and therefore musl does not implement them (1e21e78bf7). Call > syscall directly to ensure the behavior of the libc of user application, > not the libc that was used to build QEMU. > > Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com> > --- > linux-user/syscall.c | 34 ++++++++++++++++++++++++---------- > linux-user/syscall_defs.h | 4 ++++ > 2 files changed, 28 insertions(+), 10 deletions(-) > > diff --git a/linux-user/syscall.c b/linux-user/syscall.c > index 1b8415c8a3..30962155a6 100644 > --- a/linux-user/syscall.c > +++ b/linux-user/syscall.c > @@ -359,6 +359,17 @@ _syscall4(int, sys_sched_getattr, pid_t, pid, struct sched_attr *, attr, > #define __NR_sys_sched_setattr __NR_sched_setattr > _syscall3(int, sys_sched_setattr, pid_t, pid, struct sched_attr *, attr, > unsigned int, flags); > +#define __NR_sys_sched_getscheduler __NR_sched_getscheduler > +_syscall1(int, sys_sched_getscheduler, pid_t, pid); > +#define __NR_sys_sched_setscheduler __NR_sched_setscheduler > +_syscall3(int, sys_sched_setscheduler, pid_t, pid, int, policy, > + const struct sched_param *, param); > +#define __NR_sys_sched_getparam __NR_sched_getparam > +_syscall2(int, sys_sched_getparam, pid_t, pid, > + struct sched_param *, param); > +#define __NR_sys_sched_setparam __NR_sched_setparam > +_syscall2(int, sys_sched_setparam, pid_t, pid, > + const struct sched_param *, param); > #define __NR_sys_getcpu __NR_getcpu > _syscall3(int, sys_getcpu, unsigned *, cpu, unsigned *, node, void *, tcache); > _syscall4(int, reboot, int, magic1, int, magic2, unsigned int, cmd, > @@ -10587,30 +10598,32 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1, > return ret; > case TARGET_NR_sched_setparam: > { > - struct sched_param *target_schp; > + struct target_sched_param *target_schp; > struct sched_param schp; > > if (arg2 == 0) { > return -TARGET_EINVAL; > } > - if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1)) > + if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1)) { > return -TARGET_EFAULT; > + } > schp.sched_priority = tswap32(target_schp->sched_priority); > unlock_user_struct(target_schp, arg2, 0); > - return get_errno(sched_setparam(arg1, &schp)); > + return get_errno(sys_sched_setparam(arg1, &schp)); > } > case TARGET_NR_sched_getparam: > { > - struct sched_param *target_schp; > + struct target_sched_param *target_schp; > struct sched_param schp; > > if (arg2 == 0) { > return -TARGET_EINVAL; > } > - ret = get_errno(sched_getparam(arg1, &schp)); > + ret = get_errno(sys_sched_getparam(arg1, &schp)); > if (!is_error(ret)) { > - if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0)) > + if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0)) { > return -TARGET_EFAULT; > + } > target_schp->sched_priority = tswap32(schp.sched_priority); > unlock_user_struct(target_schp, arg2, 1); > } > @@ -10618,19 +10631,20 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1, > return ret; > case TARGET_NR_sched_setscheduler: > { > - struct sched_param *target_schp; > + struct target_sched_param *target_schp; > struct sched_param schp; > if (arg3 == 0) { > return -TARGET_EINVAL; > } > - if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1)) > + if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1)) { > return -TARGET_EFAULT; > + } > schp.sched_priority = tswap32(target_schp->sched_priority); > unlock_user_struct(target_schp, arg3, 0); > - return get_errno(sched_setscheduler(arg1, arg2, &schp)); > + return get_errno(sys_sched_setscheduler(arg1, arg2, &schp)); > } > case TARGET_NR_sched_getscheduler: > - return get_errno(sched_getscheduler(arg1)); > + return get_errno(sys_sched_getscheduler(arg1)); > case TARGET_NR_sched_getattr: > { > struct target_sched_attr *target_scha; > diff --git a/linux-user/syscall_defs.h b/linux-user/syscall_defs.h > index 310d6ce8ad..28b9fe9a47 100644 > --- a/linux-user/syscall_defs.h > +++ b/linux-user/syscall_defs.h > @@ -2928,4 +2928,8 @@ struct target_sched_attr { > abi_uint sched_util_max; > }; > > +struct target_sched_param { > + abi_int sched_priority; > +}; > + > #endif Reviewed-by: Laurent Vivier <laurent@vivier.eu> ^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH v4 2/2] linux-user: call set/getscheduler set/getparam directly 2022-01-05 4:18 ` [PATCH v4 2/2] linux-user: call set/getscheduler set/getparam directly Tonis Tiigi 2022-01-05 10:14 ` Laurent Vivier @ 2022-01-05 10:16 ` Laurent Vivier 1 sibling, 0 replies; 7+ messages in thread From: Laurent Vivier @ 2022-01-05 10:16 UTC (permalink / raw) To: Tonis Tiigi, qemu-devel Le 05/01/2022 à 05:18, Tonis Tiigi a écrit : > There seems to be difference in syscall and libc definition of these > methods and therefore musl does not implement them (1e21e78bf7). Call > syscall directly to ensure the behavior of the libc of user application, > not the libc that was used to build QEMU. > > Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com> > --- > linux-user/syscall.c | 34 ++++++++++++++++++++++++---------- > linux-user/syscall_defs.h | 4 ++++ > 2 files changed, 28 insertions(+), 10 deletions(-) > > diff --git a/linux-user/syscall.c b/linux-user/syscall.c > index 1b8415c8a3..30962155a6 100644 > --- a/linux-user/syscall.c > +++ b/linux-user/syscall.c > @@ -359,6 +359,17 @@ _syscall4(int, sys_sched_getattr, pid_t, pid, struct sched_attr *, attr, > #define __NR_sys_sched_setattr __NR_sched_setattr > _syscall3(int, sys_sched_setattr, pid_t, pid, struct sched_attr *, attr, > unsigned int, flags); > +#define __NR_sys_sched_getscheduler __NR_sched_getscheduler > +_syscall1(int, sys_sched_getscheduler, pid_t, pid); > +#define __NR_sys_sched_setscheduler __NR_sched_setscheduler > +_syscall3(int, sys_sched_setscheduler, pid_t, pid, int, policy, > + const struct sched_param *, param); > +#define __NR_sys_sched_getparam __NR_sched_getparam > +_syscall2(int, sys_sched_getparam, pid_t, pid, > + struct sched_param *, param); > +#define __NR_sys_sched_setparam __NR_sched_setparam > +_syscall2(int, sys_sched_setparam, pid_t, pid, > + const struct sched_param *, param); > #define __NR_sys_getcpu __NR_getcpu > _syscall3(int, sys_getcpu, unsigned *, cpu, unsigned *, node, void *, tcache); > _syscall4(int, reboot, int, magic1, int, magic2, unsigned int, cmd, > @@ -10587,30 +10598,32 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1, > return ret; > case TARGET_NR_sched_setparam: > { > - struct sched_param *target_schp; > + struct target_sched_param *target_schp; > struct sched_param schp; > > if (arg2 == 0) { > return -TARGET_EINVAL; > } > - if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1)) > + if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1)) { > return -TARGET_EFAULT; > + } > schp.sched_priority = tswap32(target_schp->sched_priority); > unlock_user_struct(target_schp, arg2, 0); > - return get_errno(sched_setparam(arg1, &schp)); > + return get_errno(sys_sched_setparam(arg1, &schp)); > } > case TARGET_NR_sched_getparam: > { > - struct sched_param *target_schp; > + struct target_sched_param *target_schp; > struct sched_param schp; > > if (arg2 == 0) { > return -TARGET_EINVAL; > } > - ret = get_errno(sched_getparam(arg1, &schp)); > + ret = get_errno(sys_sched_getparam(arg1, &schp)); > if (!is_error(ret)) { > - if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0)) > + if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0)) { > return -TARGET_EFAULT; > + } > target_schp->sched_priority = tswap32(schp.sched_priority); > unlock_user_struct(target_schp, arg2, 1); > } > @@ -10618,19 +10631,20 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1, > return ret; > case TARGET_NR_sched_setscheduler: > { > - struct sched_param *target_schp; > + struct target_sched_param *target_schp; > struct sched_param schp; > if (arg3 == 0) { > return -TARGET_EINVAL; > } > - if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1)) > + if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1)) { > return -TARGET_EFAULT; > + } > schp.sched_priority = tswap32(target_schp->sched_priority); > unlock_user_struct(target_schp, arg3, 0); > - return get_errno(sched_setscheduler(arg1, arg2, &schp)); > + return get_errno(sys_sched_setscheduler(arg1, arg2, &schp)); > } > case TARGET_NR_sched_getscheduler: > - return get_errno(sched_getscheduler(arg1)); > + return get_errno(sys_sched_getscheduler(arg1)); > case TARGET_NR_sched_getattr: > { > struct target_sched_attr *target_scha; > diff --git a/linux-user/syscall_defs.h b/linux-user/syscall_defs.h > index 310d6ce8ad..28b9fe9a47 100644 > --- a/linux-user/syscall_defs.h > +++ b/linux-user/syscall_defs.h > @@ -2928,4 +2928,8 @@ struct target_sched_attr { > abi_uint sched_util_max; > }; > > +struct target_sched_param { > + abi_int sched_priority; > +}; > + > #endif Applied to my linux-user-for-7.0 branch. Thanks, Laurent ^ permalink raw reply [flat|nested] 7+ messages in thread
end of thread, other threads:[~2022-01-05 10:19 UTC | newest] Thread overview: 7+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2022-01-05 4:18 [PATCH v4 0/2] linux-user: fixes for sched_ syscalls Tonis Tiigi 2022-01-05 4:18 ` [PATCH v4 1/2] linux-user: add sched_getattr support Tonis Tiigi 2022-01-05 10:14 ` Laurent Vivier 2022-01-05 10:16 ` Laurent Vivier 2022-01-05 4:18 ` [PATCH v4 2/2] linux-user: call set/getscheduler set/getparam directly Tonis Tiigi 2022-01-05 10:14 ` Laurent Vivier 2022-01-05 10:16 ` Laurent Vivier
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.