RepoMirrors
/
musl
mirror of git://git.musl-libc.org/musl
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
musl/arch/x32/syscall_arch.h

92 lines
3.0 KiB
C
Raw Normal View History

import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
#define __SYSCALL_LL_E(x) (x)
#define __SYSCALL_LL_O(x) (x)
x32 port (diff against vanilla x86_64)
2014-01-07 21:53:38 +00:00
#define __scc(X) sizeof(1?(X):0ULL) < 8 ? (unsigned long) (X) : (long long) (X)
mostly-cosmetic fixups to x32 port merge
2014-02-23 10:43:09 +00:00
typedef long long syscall_arg_t;
x32 port (diff against vanilla x86_64)
2014-01-07 21:53:38 +00:00
static __inline long __syscall0(long long n)
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
{
unsigned long ret;
__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n) : "rcx", "r11", "memory");
return ret;
}
x32 port (diff against vanilla x86_64)
2014-01-07 21:53:38 +00:00
static __inline long __syscall1(long long n, long long a1)
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
{
unsigned long ret;
__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1) : "rcx", "r11", "memory");
return ret;
}
x32 port (diff against vanilla x86_64)
2014-01-07 21:53:38 +00:00
static __inline long __syscall2(long long n, long long a1, long long a2)
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
{
unsigned long ret;
__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2)
x32 port (diff against vanilla x86_64)
2014-01-07 21:53:38 +00:00
: "rcx", "r11", "memory");
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
return ret;
}
x32 port (diff against vanilla x86_64)
2014-01-07 21:53:38 +00:00
static __inline long __syscall3(long long n, long long a1, long long a2, long long a3)
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
{
unsigned long ret;
__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
"d"(a3) : "rcx", "r11", "memory");
return ret;
}
x32 port (diff against vanilla x86_64)
2014-01-07 21:53:38 +00:00
static __inline long __syscall4(long long n, long long a1, long long a2, long long a3,
fix x32 syscall arch.h timespec fixup code it's legal to call the __syscall functions with more arguments than necessary, and the __syscall_cp cancel dummy impl. does just that. thus we must insert the switch for all possible syscalls numbers into all of the syscallN inline functions.
2014-02-23 19:46:30 +00:00
long long a4_)
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
{
unsigned long ret;
fix x32 syscall arch.h timespec fixup code it's legal to call the __syscall functions with more arguments than necessary, and the __syscall_cp cancel dummy impl. does just that. thus we must insert the switch for all possible syscalls numbers into all of the syscallN inline functions.
2014-02-23 19:46:30 +00:00
register long long a4 __asm__("r10") = a4_;
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
fix x32 syscall arch.h timespec fixup code it's legal to call the __syscall functions with more arguments than necessary, and the __syscall_cp cancel dummy impl. does just that. thus we must insert the switch for all possible syscalls numbers into all of the syscallN inline functions.
2014-02-23 19:46:30 +00:00
"d"(a3), "r"(a4): "rcx", "r11", "memory");
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
return ret;
}
x32 port (diff against vanilla x86_64)
2014-01-07 21:53:38 +00:00
static __inline long __syscall5(long long n, long long a1, long long a2, long long a3,
fix x32 syscall arch.h timespec fixup code it's legal to call the __syscall functions with more arguments than necessary, and the __syscall_cp cancel dummy impl. does just that. thus we must insert the switch for all possible syscalls numbers into all of the syscallN inline functions.
2014-02-23 19:46:30 +00:00
long long a4_, long long a5_)
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
{
unsigned long ret;
fix x32 syscall arch.h timespec fixup code it's legal to call the __syscall functions with more arguments than necessary, and the __syscall_cp cancel dummy impl. does just that. thus we must insert the switch for all possible syscalls numbers into all of the syscallN inline functions.
2014-02-23 19:46:30 +00:00
register long long a4 __asm__("r10") = a4_;
register long long a5 __asm__("r8") = a5_;
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
fix x32 syscall arch.h timespec fixup code it's legal to call the __syscall functions with more arguments than necessary, and the __syscall_cp cancel dummy impl. does just that. thus we must insert the switch for all possible syscalls numbers into all of the syscallN inline functions.
2014-02-23 19:46:30 +00:00
"d"(a3), "r"(a4), "r"(a5) : "rcx", "r11", "memory");
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
return ret;
}
x32 port (diff against vanilla x86_64)
2014-01-07 21:53:38 +00:00
static __inline long __syscall6(long long n, long long a1, long long a2, long long a3,
fix x32 syscall arch.h timespec fixup code it's legal to call the __syscall functions with more arguments than necessary, and the __syscall_cp cancel dummy impl. does just that. thus we must insert the switch for all possible syscalls numbers into all of the syscallN inline functions.
2014-02-23 19:46:30 +00:00
long long a4_, long long a5_, long long a6_)
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
{
unsigned long ret;
fix x32 syscall arch.h timespec fixup code it's legal to call the __syscall functions with more arguments than necessary, and the __syscall_cp cancel dummy impl. does just that. thus we must insert the switch for all possible syscalls numbers into all of the syscallN inline functions.
2014-02-23 19:46:30 +00:00
register long long a4 __asm__("r10") = a4_;
register long long a5 __asm__("r8") = a5_;
register long long a6 __asm__("r9") = a6_;
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
fix x32 syscall arch.h timespec fixup code it's legal to call the __syscall functions with more arguments than necessary, and the __syscall_cp cancel dummy impl. does just that. thus we must insert the switch for all possible syscalls numbers into all of the syscallN inline functions.
2014-02-23 19:46:30 +00:00
"d"(a3), "r"(a4), "r"(a5), "r"(a6) : "rcx", "r11", "memory");
import vanilla x86_64 code as x32
2014-01-07 21:43:34 +00:00
return ret;
}
don't use futimesat syscall as utimensat fallback on x32 kernel support for x32 was added long after the utimensat syscall was already available, so having a fallback is just wasted code size. also, for changes related to time64 support on 32-bit archs, I want to be able to assume the old futimesat syscall always works with longs, which is true except for x32. by ensuring that it's not used on x32, the needed invariant is established.
2019-07-27 16:20:07 +00:00
#undef SYS_futimesat
internally, define time64 syscalls on x32 as the existing syscalls x32 is odd in that it's the only ILP32 arch/ABI we have where time_t is 64-bit rather than (32-bit) long, and this has always been problematic in that it results in struct timespec having unused padding space, since tv_nsec has type long, which the kernel insists be zero- or sign-extended (due to negative tv_nsec being invalid, it doesn't matter which) to match the x86_64 type. up til now, we've had really ugly hacks in x32/syscall_arch.h to patch up the timespecs passed to the kernel. but the same requirement to zero- or sign-extend tv_nsec also applies to all the new time64 syscalls on true 32-bit archs. so let's take advantage of this to clean things up. this patch defines all of the time64 syscalls for x32 as aliases for the existing syscalls by the same name. this establishes the following invariants: - if the time64 form is defined, it takes time arguments as 64-bit objects, and tv_nsec inputs must be zero-/sign-extended to 64-bit. - if the time64 form is not defined, or if the time64 form is defined and is not equal to the "plain" form, the plain form takes time arguments as longs. this will avoid the need for protocols for archs to define appropriate types for each family of syscalls, and for the reader of the code to have to be aware of such type definitions. in some sense it might be simpler if the plain syscall form were undefined for x32, so that it would always take longs if defined. however, a number of these syscalls are used in contexts with a null time argument, or (e.g. futex) for commands that don't involve time at all, and having to introduce time64-specific logic to all those call points does not make sense. thus, while the "plain" forms are kept now just because they're needed until the affected code is converted over, they'll also almost surely be kept in the future as well.
2019-07-27 16:39:29 +00:00
#define SYS_clock_gettime64 SYS_clock_gettime
#define SYS_clock_settime64 SYS_clock_settime
#define SYS_clock_adjtime64 SYS_clock_adjtime
#define SYS_clock_nanosleep_time64 SYS_clock_nanosleep
#define SYS_timer_gettime64 SYS_timer_gettime
#define SYS_timer_settime64 SYS_timer_settime
#define SYS_timerfd_gettime64 SYS_timerfd_gettime
#define SYS_timerfd_settime64 SYS_timerfd_settime
#define SYS_utimensat_time64 SYS_utimensat
#define SYS_pselect6_time64 SYS_pselect6
#define SYS_ppoll_time64 SYS_ppoll
#define SYS_recvmmsg_time64 SYS_recvmmsg
#define SYS_mq_timedsend_time64 SYS_mq_timedsend
#define SYS_mq_timedreceive_time64 SYS_mq_timedreceive
#define SYS_semtimedop_time64 SYS_semtimedop
#define SYS_rt_sigtimedwait_time64 SYS_rt_sigtimedwait
#define SYS_futex_time64 SYS_futex
#define SYS_sched_rr_get_interval_time64 SYS_sched_rr_get_interval
move IPC_64 from public bits/ipc.h to syscall_arch.h the definition of the IPC_64 macro controls the interface between libc and the kernel through syscalls; it's not a public API. the meaning is rather obscure. long ago, Linux's sysvipc *id_ds structures used 16-bit uids/gids and wrong types for a few other fields. this was in the libc5 era, before glibc. the IPC_64 flag (64 is a misnomer; it's more like 32) tells the kernel to use the modern[-ish] versions of the structures. the definition of IPC_64 has nothing to do with whether the arch is 32- or 64-bit. rather, due to either historical accident or intentional obnoxiousness, the kernel only accepts and masks off the 0x100 IPC_64 flag conditional on CONFIG_ARCH_WANT_IPC_PARSE_VERSION, i.e. for archs that want to provide, or that accidentally provided, both. for archs which don't define this option, no masking is performed and commands with the 0x100 bit set will fail as invalid. so ultimately, the definition is just a matter of matching an arbitrary switch defined per-arch in the kernel.
2019-07-30 17:07:55 +00:00
#define IPC_64 0