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

150 lines
4.0 KiB
C
Raw Normal View History

syscall organization overhaul now public syscall.h only exposes __NR_* and SYS_* constants and the variadic syscall function. no macros or inline functions, no __syscall_ret or other internal details, no 16-/32-bit legacy syscall renaming, etc. this logic has all been moved to src/internal/syscall.h with the arch-specific parts in arch/$(ARCH)/syscall_arch.h, and the amount of arch-specific stuff has been reduced to a minimum. changes still need to be reviewed/double-checked. minimal testing on i386 and mips has already been performed.
2012-09-09 02:43:14 +00:00
#define __SYSCALL_LL_E(x) \
((union { long long ll; long l[2]; }){ .ll = x }).l[0], \
((union { long long ll; long l[2]; }){ .ll = x }).l[1]
#define __SYSCALL_LL_O(x) 0, __SYSCALL_LL_E((x))
fix for broken kernel side RLIM_INFINITY on mips On 32 bit mips the kernel uses -1UL/2 to mark RLIM_INFINITY (and this is the definition in the userspace api), but since it is in the middle of the valid range of limits and limits are often compared with relational operators, various kernel side logic is broken if larger than -1UL/2 limits are used. So we truncate the limits to -1UL/2 in get/setrlimit and prlimit. Even if the kernel side logic consistently treated -1UL/2 as greater than any other limit value, there wouldn't be any clean workaround that allowed using large limits: * using -1UL/2 as RLIM_INFINITY in userspace would mean different infinity value for get/setrlimt and prlimit (where infinity is always -1ULL) and userspace logic could break easily (just like the kernel is broken now) and more special case code would be needed for mips. * translating -1UL/2 kernel side value to -1ULL in userspace would mean that -1UL/2 limit cannot be set (eg. -1UL/2+1 had to be passed to the kernel instead).
2014-05-30 06:47:35 +00:00
#define SYSCALL_RLIM_INFINITY (-1UL/2)
fix mips r6 syscall clobber lists not to include hi/lo registers mips r6 (an incompatible isa from traditional mips) removes the hi and lo registers used for mul/div results. older gcc versions accepted them in the clobber list for asm, but their presence is incorrect and breaks on later versions. in the process of fixing this, the clobber list for 32-bit mips syscalls has been deduplicated via a macro like on mips64 and n32.
2019-09-26 23:14:36 +00:00
#if __mips_isa_rev >= 6
#define SYSCALL_CLOBBERLIST \
"$1", "$3", "$11", "$12", "$13", \
"$14", "$15", "$24", "$25", "memory"
#else
#define SYSCALL_CLOBBERLIST \
"$1", "$3", "$11", "$12", "$13", \
"$14", "$15", "$24", "$25", "hi", "lo", "memory"
#endif
inline syscall support for mips this drastically reduces the size of some functions which are purely syscall wrappers. disabled for clang due to known bugs satisfying register constraints.
2012-09-09 05:01:19 +00:00
static inline long __syscall0(long n)
{
improve mips syscall asm constraints to use immediates, if possible by using the "ir" constraint (immediate or register) and the carefully constructed instruction addu $2,$0,%2 which can take either an immediate or a register for %2, the new inline asm admits maximal optimization with no register spillage to the stack when the compiler successfully performs constant propagration, but still works by allocating a register when the syscall number cannot be recognized as a constant. in the case of syscalls with 0-3 arguments it barely matters, but for 4-argument syscalls, using an immediate for the syscall number avoids creating a stack frame for the syscall wrapper function.
2012-09-11 06:23:47 +00:00
register long r7 __asm__("$7");
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
register long r2 __asm__("$2") = n;
fix mips struct stat dev_t members for big endian the mips version of this structure on the kernel side wrongly has 32-bit type rather than 64-bit type. fortunately there is adjacent padding to bring it up to 64 bits, and on little-endian, this allows us to treat the adjacent kernel st_dev and st_pad0[0] as as single 64-bit dev_t. however, on big endian, such treatment results in the upper and lower 32-bit parts of the dev_t value being swapped. for the purpose of just comparing st_dev values this did not break anything, but it precluded actually processing the device numbers as major/minor values. since the broken kernel behavior that needs to be worked around is isolated to one arch, I put the workarounds in syscall_arch.h rather than adding a stat fixup path in the common code. on little endian mips, the added code optimizes out completely. the changes necessary were incompatible with the way the __asm_syscall macro was factored so I just removed it and flattened the individual __syscallN functions. this arguably makes the code easier to read and understand, anyway.
2014-07-20 03:37:21 +00:00
__asm__ __volatile__ (
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
"syscall"
: "+r"(r2), "=r"(r7)
:
fix mips r6 syscall clobber lists not to include hi/lo registers mips r6 (an incompatible isa from traditional mips) removes the hi and lo registers used for mul/div results. older gcc versions accepted them in the clobber list for asm, but their presence is incorrect and breaks on later versions. in the process of fixing this, the clobber list for 32-bit mips syscalls has been deduplicated via a macro like on mips64 and n32.
2019-09-26 23:14:36 +00:00
: SYSCALL_CLOBBERLIST, "$8", "$9", "$10");
fix mips struct stat dev_t members for big endian the mips version of this structure on the kernel side wrongly has 32-bit type rather than 64-bit type. fortunately there is adjacent padding to bring it up to 64 bits, and on little-endian, this allows us to treat the adjacent kernel st_dev and st_pad0[0] as as single 64-bit dev_t. however, on big endian, such treatment results in the upper and lower 32-bit parts of the dev_t value being swapped. for the purpose of just comparing st_dev values this did not break anything, but it precluded actually processing the device numbers as major/minor values. since the broken kernel behavior that needs to be worked around is isolated to one arch, I put the workarounds in syscall_arch.h rather than adding a stat fixup path in the common code. on little endian mips, the added code optimizes out completely. the changes necessary were incompatible with the way the __asm_syscall macro was factored so I just removed it and flattened the individual __syscallN functions. this arguably makes the code easier to read and understand, anyway.
2014-07-20 03:37:21 +00:00
return r7 ? -r2 : r2;
inline syscall support for mips this drastically reduces the size of some functions which are purely syscall wrappers. disabled for clang due to known bugs satisfying register constraints.
2012-09-09 05:01:19 +00:00
}
static inline long __syscall1(long n, long a)
{
register long r4 __asm__("$4") = a;
improve mips syscall asm constraints to use immediates, if possible by using the "ir" constraint (immediate or register) and the carefully constructed instruction addu $2,$0,%2 which can take either an immediate or a register for %2, the new inline asm admits maximal optimization with no register spillage to the stack when the compiler successfully performs constant propagration, but still works by allocating a register when the syscall number cannot be recognized as a constant. in the case of syscalls with 0-3 arguments it barely matters, but for 4-argument syscalls, using an immediate for the syscall number avoids creating a stack frame for the syscall wrapper function.
2012-09-11 06:23:47 +00:00
register long r7 __asm__("$7");
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
register long r2 __asm__("$2") = n;
fix mips struct stat dev_t members for big endian the mips version of this structure on the kernel side wrongly has 32-bit type rather than 64-bit type. fortunately there is adjacent padding to bring it up to 64 bits, and on little-endian, this allows us to treat the adjacent kernel st_dev and st_pad0[0] as as single 64-bit dev_t. however, on big endian, such treatment results in the upper and lower 32-bit parts of the dev_t value being swapped. for the purpose of just comparing st_dev values this did not break anything, but it precluded actually processing the device numbers as major/minor values. since the broken kernel behavior that needs to be worked around is isolated to one arch, I put the workarounds in syscall_arch.h rather than adding a stat fixup path in the common code. on little endian mips, the added code optimizes out completely. the changes necessary were incompatible with the way the __asm_syscall macro was factored so I just removed it and flattened the individual __syscallN functions. this arguably makes the code easier to read and understand, anyway.
2014-07-20 03:37:21 +00:00
__asm__ __volatile__ (
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
"syscall"
: "+r"(r2), "=r"(r7)
: "r"(r4)
fix mips r6 syscall clobber lists not to include hi/lo registers mips r6 (an incompatible isa from traditional mips) removes the hi and lo registers used for mul/div results. older gcc versions accepted them in the clobber list for asm, but their presence is incorrect and breaks on later versions. in the process of fixing this, the clobber list for 32-bit mips syscalls has been deduplicated via a macro like on mips64 and n32.
2019-09-26 23:14:36 +00:00
: SYSCALL_CLOBBERLIST, "$8", "$9", "$10");
fix mips struct stat dev_t members for big endian the mips version of this structure on the kernel side wrongly has 32-bit type rather than 64-bit type. fortunately there is adjacent padding to bring it up to 64 bits, and on little-endian, this allows us to treat the adjacent kernel st_dev and st_pad0[0] as as single 64-bit dev_t. however, on big endian, such treatment results in the upper and lower 32-bit parts of the dev_t value being swapped. for the purpose of just comparing st_dev values this did not break anything, but it precluded actually processing the device numbers as major/minor values. since the broken kernel behavior that needs to be worked around is isolated to one arch, I put the workarounds in syscall_arch.h rather than adding a stat fixup path in the common code. on little endian mips, the added code optimizes out completely. the changes necessary were incompatible with the way the __asm_syscall macro was factored so I just removed it and flattened the individual __syscallN functions. this arguably makes the code easier to read and understand, anyway.
2014-07-20 03:37:21 +00:00
return r7 ? -r2 : r2;
inline syscall support for mips this drastically reduces the size of some functions which are purely syscall wrappers. disabled for clang due to known bugs satisfying register constraints.
2012-09-09 05:01:19 +00:00
}
static inline long __syscall2(long n, long a, long b)
{
register long r4 __asm__("$4") = a;
register long r5 __asm__("$5") = b;
improve mips syscall asm constraints to use immediates, if possible by using the "ir" constraint (immediate or register) and the carefully constructed instruction addu $2,$0,%2 which can take either an immediate or a register for %2, the new inline asm admits maximal optimization with no register spillage to the stack when the compiler successfully performs constant propagration, but still works by allocating a register when the syscall number cannot be recognized as a constant. in the case of syscalls with 0-3 arguments it barely matters, but for 4-argument syscalls, using an immediate for the syscall number avoids creating a stack frame for the syscall wrapper function.
2012-09-11 06:23:47 +00:00
register long r7 __asm__("$7");
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
register long r2 __asm__("$2") = n;
fix mips struct stat dev_t members for big endian the mips version of this structure on the kernel side wrongly has 32-bit type rather than 64-bit type. fortunately there is adjacent padding to bring it up to 64 bits, and on little-endian, this allows us to treat the adjacent kernel st_dev and st_pad0[0] as as single 64-bit dev_t. however, on big endian, such treatment results in the upper and lower 32-bit parts of the dev_t value being swapped. for the purpose of just comparing st_dev values this did not break anything, but it precluded actually processing the device numbers as major/minor values. since the broken kernel behavior that needs to be worked around is isolated to one arch, I put the workarounds in syscall_arch.h rather than adding a stat fixup path in the common code. on little endian mips, the added code optimizes out completely. the changes necessary were incompatible with the way the __asm_syscall macro was factored so I just removed it and flattened the individual __syscallN functions. this arguably makes the code easier to read and understand, anyway.
2014-07-20 03:37:21 +00:00
__asm__ __volatile__ (
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
"syscall"
: "+r"(r2), "=r"(r7)
: "r"(r4), "r"(r5)
fix mips r6 syscall clobber lists not to include hi/lo registers mips r6 (an incompatible isa from traditional mips) removes the hi and lo registers used for mul/div results. older gcc versions accepted them in the clobber list for asm, but their presence is incorrect and breaks on later versions. in the process of fixing this, the clobber list for 32-bit mips syscalls has been deduplicated via a macro like on mips64 and n32.
2019-09-26 23:14:36 +00:00
: SYSCALL_CLOBBERLIST, "$8", "$9", "$10");
remove mips/n32/64 stat struct hacks from syscall machinery now that we have a kstat structure decoupled from the public struct stat, we can just use the broken kernel structures directly and let the code in fstatat do the translation.
2019-07-18 23:07:32 +00:00
return r7 ? -r2 : r2;
inline syscall support for mips this drastically reduces the size of some functions which are purely syscall wrappers. disabled for clang due to known bugs satisfying register constraints.
2012-09-09 05:01:19 +00:00
}
static inline long __syscall3(long n, long a, long b, long c)
{
register long r4 __asm__("$4") = a;
register long r5 __asm__("$5") = b;
register long r6 __asm__("$6") = c;
improve mips syscall asm constraints to use immediates, if possible by using the "ir" constraint (immediate or register) and the carefully constructed instruction addu $2,$0,%2 which can take either an immediate or a register for %2, the new inline asm admits maximal optimization with no register spillage to the stack when the compiler successfully performs constant propagration, but still works by allocating a register when the syscall number cannot be recognized as a constant. in the case of syscalls with 0-3 arguments it barely matters, but for 4-argument syscalls, using an immediate for the syscall number avoids creating a stack frame for the syscall wrapper function.
2012-09-11 06:23:47 +00:00
register long r7 __asm__("$7");
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
register long r2 __asm__("$2") = n;
fix mips struct stat dev_t members for big endian the mips version of this structure on the kernel side wrongly has 32-bit type rather than 64-bit type. fortunately there is adjacent padding to bring it up to 64 bits, and on little-endian, this allows us to treat the adjacent kernel st_dev and st_pad0[0] as as single 64-bit dev_t. however, on big endian, such treatment results in the upper and lower 32-bit parts of the dev_t value being swapped. for the purpose of just comparing st_dev values this did not break anything, but it precluded actually processing the device numbers as major/minor values. since the broken kernel behavior that needs to be worked around is isolated to one arch, I put the workarounds in syscall_arch.h rather than adding a stat fixup path in the common code. on little endian mips, the added code optimizes out completely. the changes necessary were incompatible with the way the __asm_syscall macro was factored so I just removed it and flattened the individual __syscallN functions. this arguably makes the code easier to read and understand, anyway.
2014-07-20 03:37:21 +00:00
__asm__ __volatile__ (
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
"syscall"
: "+r"(r2), "=r"(r7)
: "r"(r4), "r"(r5), "r"(r6)
fix mips r6 syscall clobber lists not to include hi/lo registers mips r6 (an incompatible isa from traditional mips) removes the hi and lo registers used for mul/div results. older gcc versions accepted them in the clobber list for asm, but their presence is incorrect and breaks on later versions. in the process of fixing this, the clobber list for 32-bit mips syscalls has been deduplicated via a macro like on mips64 and n32.
2019-09-26 23:14:36 +00:00
: SYSCALL_CLOBBERLIST, "$8", "$9", "$10");
remove mips/n32/64 stat struct hacks from syscall machinery now that we have a kstat structure decoupled from the public struct stat, we can just use the broken kernel structures directly and let the code in fstatat do the translation.
2019-07-18 23:07:32 +00:00
return r7 ? -r2 : r2;
improve mips syscall asm constraints to use immediates, if possible by using the "ir" constraint (immediate or register) and the carefully constructed instruction addu $2,$0,%2 which can take either an immediate or a register for %2, the new inline asm admits maximal optimization with no register spillage to the stack when the compiler successfully performs constant propagration, but still works by allocating a register when the syscall number cannot be recognized as a constant. in the case of syscalls with 0-3 arguments it barely matters, but for 4-argument syscalls, using an immediate for the syscall number avoids creating a stack frame for the syscall wrapper function.
2012-09-11 06:23:47 +00:00
}
static inline long __syscall4(long n, long a, long b, long c, long d)
{
register long r4 __asm__("$4") = a;
register long r5 __asm__("$5") = b;
register long r6 __asm__("$6") = c;
register long r7 __asm__("$7") = d;
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
register long r2 __asm__("$2") = n;
fix mips struct stat dev_t members for big endian the mips version of this structure on the kernel side wrongly has 32-bit type rather than 64-bit type. fortunately there is adjacent padding to bring it up to 64 bits, and on little-endian, this allows us to treat the adjacent kernel st_dev and st_pad0[0] as as single 64-bit dev_t. however, on big endian, such treatment results in the upper and lower 32-bit parts of the dev_t value being swapped. for the purpose of just comparing st_dev values this did not break anything, but it precluded actually processing the device numbers as major/minor values. since the broken kernel behavior that needs to be worked around is isolated to one arch, I put the workarounds in syscall_arch.h rather than adding a stat fixup path in the common code. on little endian mips, the added code optimizes out completely. the changes necessary were incompatible with the way the __asm_syscall macro was factored so I just removed it and flattened the individual __syscallN functions. this arguably makes the code easier to read and understand, anyway.
2014-07-20 03:37:21 +00:00
__asm__ __volatile__ (
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
"syscall"
: "+r"(r2), "+r"(r7)
: "r"(r4), "r"(r5), "r"(r6)
fix mips r6 syscall clobber lists not to include hi/lo registers mips r6 (an incompatible isa from traditional mips) removes the hi and lo registers used for mul/div results. older gcc versions accepted them in the clobber list for asm, but their presence is incorrect and breaks on later versions. in the process of fixing this, the clobber list for 32-bit mips syscalls has been deduplicated via a macro like on mips64 and n32.
2019-09-26 23:14:36 +00:00
: SYSCALL_CLOBBERLIST, "$8", "$9", "$10");
remove mips/n32/64 stat struct hacks from syscall machinery now that we have a kstat structure decoupled from the public struct stat, we can just use the broken kernel structures directly and let the code in fstatat do the translation.
2019-07-18 23:07:32 +00:00
return r7 ? -r2 : r2;
inline syscall support for mips this drastically reduces the size of some functions which are purely syscall wrappers. disabled for clang due to known bugs satisfying register constraints.
2012-09-09 05:01:19 +00:00
}
syscall organization overhaul now public syscall.h only exposes __NR_* and SYS_* constants and the variadic syscall function. no macros or inline functions, no __syscall_ret or other internal details, no 16-/32-bit legacy syscall renaming, etc. this logic has all been moved to src/internal/syscall.h with the arch-specific parts in arch/$(ARCH)/syscall_arch.h, and the amount of arch-specific stuff has been reduced to a minimum. changes still need to be reviewed/double-checked. minimal testing on i386 and mips has already been performed.
2012-09-09 02:43:14 +00:00
static inline long __syscall5(long n, long a, long b, long c, long d, long e)
{
implement inline 5- and 6-argument syscalls for mips the OABI passes these on the stack, using the convention that their position on the stack is as if the first four arguments (in registers) also had stack slots. originally this was deemed too awkward to do inline, falling back to external __syscall, but it's not that bad and now that external __syscall is being removed, it's necessary.
2019-04-10 23:23:15 +00:00
register long r4 __asm__("$4") = a;
register long r5 __asm__("$5") = b;
register long r6 __asm__("$6") = c;
register long r7 __asm__("$7") = d;
register long r8 __asm__("$8") = e;
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
register long r2 __asm__("$2") = n;
implement inline 5- and 6-argument syscalls for mips the OABI passes these on the stack, using the convention that their position on the stack is as if the first four arguments (in registers) also had stack slots. originally this was deemed too awkward to do inline, falling back to external __syscall, but it's not that bad and now that external __syscall is being removed, it's necessary.
2019-04-10 23:23:15 +00:00
__asm__ __volatile__ (
"subu $sp,$sp,32 ; sw $8,16($sp) ; "
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
"syscall ;"
implement inline 5- and 6-argument syscalls for mips the OABI passes these on the stack, using the convention that their position on the stack is as if the first four arguments (in registers) also had stack slots. originally this was deemed too awkward to do inline, falling back to external __syscall, but it's not that bad and now that external __syscall is being removed, it's necessary.
2019-04-10 23:23:15 +00:00
"addu $sp,$sp,32"
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
: "+r"(r2), "+r"(r7), "+r"(r8)
: "r"(r4), "r"(r5), "r"(r6)
fix mips r6 syscall clobber lists not to include hi/lo registers mips r6 (an incompatible isa from traditional mips) removes the hi and lo registers used for mul/div results. older gcc versions accepted them in the clobber list for asm, but their presence is incorrect and breaks on later versions. in the process of fixing this, the clobber list for 32-bit mips syscalls has been deduplicated via a macro like on mips64 and n32.
2019-09-26 23:14:36 +00:00
: SYSCALL_CLOBBERLIST, "$9", "$10");
remove mips/n32/64 stat struct hacks from syscall machinery now that we have a kstat structure decoupled from the public struct stat, we can just use the broken kernel structures directly and let the code in fstatat do the translation.
2019-07-18 23:07:32 +00:00
return r7 ? -r2 : r2;
syscall organization overhaul now public syscall.h only exposes __NR_* and SYS_* constants and the variadic syscall function. no macros or inline functions, no __syscall_ret or other internal details, no 16-/32-bit legacy syscall renaming, etc. this logic has all been moved to src/internal/syscall.h with the arch-specific parts in arch/$(ARCH)/syscall_arch.h, and the amount of arch-specific stuff has been reduced to a minimum. changes still need to be reviewed/double-checked. minimal testing on i386 and mips has already been performed.
2012-09-09 02:43:14 +00:00
}
static inline long __syscall6(long n, long a, long b, long c, long d, long e, long f)
{
implement inline 5- and 6-argument syscalls for mips the OABI passes these on the stack, using the convention that their position on the stack is as if the first four arguments (in registers) also had stack slots. originally this was deemed too awkward to do inline, falling back to external __syscall, but it's not that bad and now that external __syscall is being removed, it's necessary.
2019-04-10 23:23:15 +00:00
register long r4 __asm__("$4") = a;
register long r5 __asm__("$5") = b;
register long r6 __asm__("$6") = c;
register long r7 __asm__("$7") = d;
register long r8 __asm__("$8") = e;
register long r9 __asm__("$9") = f;
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
register long r2 __asm__("$2") = n;
implement inline 5- and 6-argument syscalls for mips the OABI passes these on the stack, using the convention that their position on the stack is as if the first four arguments (in registers) also had stack slots. originally this was deemed too awkward to do inline, falling back to external __syscall, but it's not that bad and now that external __syscall is being removed, it's necessary.
2019-04-10 23:23:15 +00:00
__asm__ __volatile__ (
"subu $sp,$sp,32 ; sw $8,16($sp) ; sw $9,20($sp) ; "
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
"syscall ;"
implement inline 5- and 6-argument syscalls for mips the OABI passes these on the stack, using the convention that their position on the stack is as if the first four arguments (in registers) also had stack slots. originally this was deemed too awkward to do inline, falling back to external __syscall, but it's not that bad and now that external __syscall is being removed, it's necessary.
2019-04-10 23:23:15 +00:00
"addu $sp,$sp,32"
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
: "+r"(r2), "+r"(r7), "+r"(r8), "+r"(r9)
: "r"(r4), "r"(r5), "r"(r6)
fix mips r6 syscall clobber lists not to include hi/lo registers mips r6 (an incompatible isa from traditional mips) removes the hi and lo registers used for mul/div results. older gcc versions accepted them in the clobber list for asm, but their presence is incorrect and breaks on later versions. in the process of fixing this, the clobber list for 32-bit mips syscalls has been deduplicated via a macro like on mips64 and n32.
2019-09-26 23:14:36 +00:00
: SYSCALL_CLOBBERLIST, "$10");
remove mips/n32/64 stat struct hacks from syscall machinery now that we have a kstat structure decoupled from the public struct stat, we can just use the broken kernel structures directly and let the code in fstatat do the translation.
2019-07-18 23:07:32 +00:00
return r7 ? -r2 : r2;
syscall organization overhaul now public syscall.h only exposes __NR_* and SYS_* constants and the variadic syscall function. no macros or inline functions, no __syscall_ret or other internal details, no 16-/32-bit legacy syscall renaming, etc. this logic has all been moved to src/internal/syscall.h with the arch-specific parts in arch/$(ARCH)/syscall_arch.h, and the amount of arch-specific stuff has been reduced to a minimum. changes still need to be reviewed/double-checked. minimal testing on i386 and mips has already been performed.
2012-09-09 02:43:14 +00:00
}
mips: add vdso support vdso support is available on mips starting with kernel 4.4, see kernel commit a7f4df4e21 "MIPS: VDSO: Add implementations of gettimeofday() and clock_gettime()" for details. In Linux kernel 4.4.0 the mips code returns -ENOSYS in case it can not handle the vdso call and assumes the libc will call the original syscall in this case. Handle this case in musl. Currently Linux kernel 4.4.0 handles the following types: CLOCK_REALTIME_COARSE, CLOCK_MONOTONIC_COARSE, CLOCK_REALTIME and CLOCK_MONOTONIC.
2016-01-26 20:26:34 +00:00
fix broken posix_fadvise on mips due to missing 7-arg syscall support commit 788d5e24ca19c6291cebd8d1ad5b5ed6abf42665 exposed the breakage at build time by removing support for 7-argument syscalls; however, the external __syscall function provided for mips before did not pass a 7th argument from the stack, so the behavior was just silently broken.
2019-05-05 15:24:57 +00:00
static inline long __syscall7(long n, long a, long b, long c, long d, long e, long f, long g)
{
register long r4 __asm__("$4") = a;
register long r5 __asm__("$5") = b;
register long r6 __asm__("$6") = c;
register long r7 __asm__("$7") = d;
register long r8 __asm__("$8") = e;
register long r9 __asm__("$9") = f;
register long r10 __asm__("$10") = g;
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
register long r2 __asm__("$2") = n;
fix broken posix_fadvise on mips due to missing 7-arg syscall support commit 788d5e24ca19c6291cebd8d1ad5b5ed6abf42665 exposed the breakage at build time by removing support for 7-argument syscalls; however, the external __syscall function provided for mips before did not pass a 7th argument from the stack, so the behavior was just silently broken.
2019-05-05 15:24:57 +00:00
__asm__ __volatile__ (
"subu $sp,$sp,32 ; sw $8,16($sp) ; sw $9,20($sp) ; sw $10,24($sp) ; "
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
"syscall ;"
fix broken posix_fadvise on mips due to missing 7-arg syscall support commit 788d5e24ca19c6291cebd8d1ad5b5ed6abf42665 exposed the breakage at build time by removing support for 7-argument syscalls; however, the external __syscall function provided for mips before did not pass a 7th argument from the stack, so the behavior was just silently broken.
2019-05-05 15:24:57 +00:00
"addu $sp,$sp,32"
clean up mips (32-bit, o32) syscall asm constraints analogous to commit ddc7c4f936c7a90781072f10dbaa122007e939d0 for mips64 and n32, remove the hack to load the syscall number into $2 via asm, and use a constraint to let the compiler load it instead. now, only $4, $5, and $6 are potential input-only registers. $2 is always input and output, and $7 is both when it's an argument, otherwise output-only. previously, $7 was treated as an input (with a "1" constraint matching its output position) even when it was not an input, which was arguably undefined behavior (asm input from indeterminate value). this is corrected. as before, $8, $9, and $10 are conditionally input-output registers for 5-, 6-, and 7-argument syscalls. their role in input is carrying in the values that will be stored on the stack for arguments 5-7. their role in output is carrying back whatever the kernel has clobbered them with, so that the compiler cannot assume they still contain the input values.
2019-09-27 13:57:54 +00:00
: "+r"(r2), "+r"(r7), "+r"(r8), "+r"(r9), "+r"(r10)
: "r"(r4), "r"(r5), "r"(r6)
fix mips r6 syscall clobber lists not to include hi/lo registers mips r6 (an incompatible isa from traditional mips) removes the hi and lo registers used for mul/div results. older gcc versions accepted them in the clobber list for asm, but their presence is incorrect and breaks on later versions. in the process of fixing this, the clobber list for 32-bit mips syscalls has been deduplicated via a macro like on mips64 and n32.
2019-09-26 23:14:36 +00:00
: SYSCALL_CLOBBERLIST);
remove mips/n32/64 stat struct hacks from syscall machinery now that we have a kstat structure decoupled from the public struct stat, we can just use the broken kernel structures directly and let the code in fstatat do the translation.
2019-07-18 23:07:32 +00:00
return r7 ? -r2 : r2;
fix broken posix_fadvise on mips due to missing 7-arg syscall support commit 788d5e24ca19c6291cebd8d1ad5b5ed6abf42665 exposed the breakage at build time by removing support for 7-argument syscalls; however, the external __syscall function provided for mips before did not pass a 7th argument from the stack, so the behavior was just silently broken.
2019-05-05 15:24:57 +00:00
}
mips: add vdso support vdso support is available on mips starting with kernel 4.4, see kernel commit a7f4df4e21 "MIPS: VDSO: Add implementations of gettimeofday() and clock_gettime()" for details. In Linux kernel 4.4.0 the mips code returns -ENOSYS in case it can not handle the vdso call and assumes the libc will call the original syscall in this case. Handle this case in musl. Currently Linux kernel 4.4.0 handles the following types: CLOCK_REALTIME_COARSE, CLOCK_MONOTONIC_COARSE, CLOCK_REALTIME and CLOCK_MONOTONIC.
2016-01-26 20:26:34 +00:00
#define VDSO_USEFUL
#define VDSO_CGT_SYM "__vdso_clock_gettime"
#define VDSO_CGT_VER "LINUX_2.6"
get/setsockopt: add fallback for new time64 SO_RCVTIMEO/SO_SNDTIMEO without this, the SO_RCVTIMEO and SO_SNDTIMEO socket options would stop working on pre-5.1 kernels after time_t is switched to 64-bit and their values are changed to the new time64 versions. new code is written such that it's statically unreachable on 64-bit archs, and on existing 32-bit archs until the macro values are changed to activate 64-bit time_t.
2019-07-31 02:11:39 +00:00
#define SO_SNDTIMEO_OLD 0x1005
#define SO_RCVTIMEO_OLD 0x1006