Automate initrd generation for v4.21/v5.0
Subsystems (2)
cover Automate initrd generation for v4.21/v5.0
Hello!
This series causes rcutorture to automatically generate the required initrd when needed, instead of giving very obtuse error messages.
1. Automatically create initrd directory, courtesy of Connor Shu.
2. Add initrd support for systems lacking dracut.
3. Make initrd/init execute in userspace.
4. Add cross-compile capability to initrd.sh.
5. Always strip using the cross-compiler, courtesy of Willy Tarreau.
6. Check initrd/init instead of initrd only, courtesy of Willy Tarreau.
7. Import a copy of nolibc, courtesy of Willy Tarreau.
8. Make use of nolibc when available, courtesy of Willy Tarreau.
Thanx, Paul
------------------------------------------------------------------------
bin/kvm.sh | 8 bin/mkinitrd.sh | 174 +++- bin/nolibc.h | 2197 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ doc/initrd.txt | 99 -- 4 files changed, 2372 insertions(+), 106 deletions(-)
PATCH 1/8 rcutorture: Automatically create initrd directory
From: Connor Shu <[email protected]>
The rcutorture scripts currently expect the user to create the tools/testing/selftests/rcutorture/initrd directory. Should the user fail to do this, the kernel build will fail with obscure and confusing error messages. This commit therefore adds explicit checks for the tools/testing/selftests/rcutorture/initrd directory, and if not present, creates one on systems on which dracut is installed. If this directory could not be created, a less obscure error message is emitted and the test is aborted.
Suggested-by Thomas Gleixner <[email protected]>
Signed-off-by Connor Shu <[email protected]>
[ paulmck: Adapt the script to fit into the rcutorture framework and
severely abbreviate the initrd/init script. ]
Signed-off-by Paul E. McKenney <[email protected]>
--- tools/testing/selftests/rcutorture/bin/kvm.sh | 8 +++ .../selftests/rcutorture/bin/mkinitrd.sh | 60 +++++++++++++++++++ 2 files changed, 68 insertions(+) create mode 100755 tools/testing/selftests/rcutorture/bin/mkinitrd.sh
tools/testing/selftests/rcutorture/bin/kvm.sh +8 -0
@@ -194,6 +194,14 @@ do shift done +if test -z "$TORTURE_INITRD" || tools/testing/selftests/rcutorture/bin/mkinitrd.sh +then + : +else + echo No initrd and unable to create one, aborting test >&2 + exit 1 +fi + CONFIGFRAG=${KVM}/configs/${TORTURE_SUITE}; export CONFIGFRAG if test -z "$configs"
tools/testing/selftests/rcutorture/bin/mkinitrd.sh new file +60 -0
60 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH 2/8 rcutorture: Add initrd support for systems lacking dracut
In reply to Paul E. McKenneyFrom: "Paul E. McKenney" <[email protected]>
The support for creating initrd directories using dracut is a great improvement over having to always hand-create them, it is a bit annoying to have to install some otherwise irrelevant package just to be able to run rcutorture. This commit therefore adds support for creating initrd directories on systems innocent of dracut. You do need gcc, but then again you need that to build the kernel (or to build llvm) in any case.
The idea is to create an initrd directory containing nothing but a statically linked binary having a for-loop over a long-term sleep(). The result is a Linux kernel with almost no userspace: even the time-honored /dev, /lib, /tmp, and /usr directories are gone. In fact, the only directory present is "/", but only because I don't know how to get rid of it, at least short of not having an initrd in the first place. Although statically linked binaries are much maligned, and rightly so, their disadvantages seem to be irrelevant for this particular use case. From https://www.akkadia.org/drepper/no_static_linking.html:
1. Fixes are difficult to apply to hordes of widely scattered
statically linked binaries. But in this case, there is only one binary, but there would otherwise be no fewer than four libraries.
2. Security measures like local address randomization cannot be used.
Prudence prevents me from asserting that it is impossible to base a remote attack on a networking-free rcutorture instance. Nevertheless, bonus points to the first person who comes up with such an attack!
3. More efficient use of physical memory. Not in this case, given
that libc is 1.8MB and the statically linked binary "only" 800K.
4. Features such as locales, name service switch (NSS),
internationalized domain names (IDN) tool, and so on require dynamic linking. Bonus points to the first person coming up with a valid rcutorture use case requiring these features in its initrd.
5. Accidental violations of (L)GPL. Actually, this change actually
helps -avoid- such violations by reducing the temptation to pass around tarballs of rcutorture-ready initrd directories. After all, the rcutorture scripts automatically create an initrd directory for you, so why bother with the tarballs?
6. Tools and hacks like ltrace, LD_PRELOAD, LD_PROFILE, and LD_AUDIT
don't work. Again, bonus points to the first person coming up with a valid rcutorture use case requiring these features in its initrd.
Nevertheless, the script will use dracut if available, and will create the statically linked binary only when dracut are missing. Those preferring the smaller initrd directory resulting from the statically linked binary (like me) are free to hand-edit mkinitrd.sh to remove the code using dracut. ;-)
Signed-off-by Paul E. McKenney <[email protected]>
--- .../selftests/rcutorture/bin/mkinitrd.sh | 40 ++++++-- .../selftests/rcutorture/doc/initrd.txt | 99 +++---------------- 2 files changed, 45 insertions(+), 94 deletions(-)
tools/testing/selftests/rcutorture/bin/mkinitrd.sh +33 -7
@@ -46,15 +46,41 @@ done __EOF___ # Try using dracut to create initrd -command -v dracut >/dev/null 2>&1 || { echo >&2 "Dracut not installed"; exit 1; } -echo Creating $D/initrd using dracut. +if command -v dracut >/dev/null 2>&1 +then + echo Creating $D/initrd using dracut. + # Filesystem creation + dracut --force --no-hostonly --no-hostonly-cmdline --module "base" $T/initramfs.img + cd $D + mkdir initrd + cd initrd + zcat $T/initramfs.img | cpio -id + cp $T/init init + chmod +x init + echo Done creating $D/initrd using dracut + exit 0 +fi -# Filesystem creation -dracut --force --no-hostonly --no-hostonly-cmdline --module "base" $T/initramfs.img +# No dracut, so create a C-language initrd/init program and statically +# link it. This results in a very small initrd, but might be a bit less +# future-proof than dracut. +echo "Could not find dracut, attempting C initrd" cd $D mkdir initrd cd initrd -zcat $T/initramfs.img | cpio -id -cp $T/init init -echo Done creating $D/initrd using dracut +cat > init.c << '___EOF___' +#include <unistd.h> + +int main(int argc, int argv[]) +{ + for (;;) + sleep(1000*1000*1000); /* One gigasecond is ~30 years. */ + return 0; +} +___EOF___ +gcc -static -Os -o init init.c +strip init +rm init.c +echo "Done creating a statically linked C-language initrd" + exit 0
tools/testing/selftests/rcutorture/doc/initrd.txt +12 -87
118 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH 3/8 rcutorture: Make initrd/init execute in userspace
In reply to Paul E. McKenneyFrom: "Paul E. McKenney" <[email protected]>
Currently, the initrd/init script and executable remain blocked almost all the time. However, it is necessary to test nohz_full userspace execution, which both variants of initrd/init fail to do. This commit therefore causes initrd/init to spend about a millisecond per second executing in userspace.
Reported-by Josh Triplett <[email protected]>
Signed-off-by Paul E. McKenney <[email protected]>
--- .../selftests/rcutorture/bin/mkinitrd.sh | 43 +++++++++++++++++-- 1 file changed, 39 insertions(+), 4 deletions(-)
tools/testing/selftests/rcutorture/bin/mkinitrd.sh +39 -4
@@ -39,9 +39,22 @@ mkdir $T cat > $T/init << '__EOF___' #!/bin/sh +# Run in userspace a few milliseconds every second. This helps to +# exercise the NO_HZ_FULL portions of RCU. while : do - sleep 1000000 + q= + for i in \ + a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a \ + a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a \ + a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a \ + a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a \ + a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a \ + a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a + do + q="$q $i" + done + sleep 1 done __EOF___
@@ -70,15 +83,37 @@ mkdir initrd cd initrd cat > init.c << '___EOF___' #include <unistd.h> +#include <sys/time.h> + +volatile unsigned long delaycount; int main(int argc, int argv[]) { - for (;;) - sleep(1000*1000*1000); /* One gigasecond is ~30 years. */ + int i; + struct timeval tv; + struct timeval tvb; + + for (;;) { + sleep(1); + /* Need some userspace time. */ + if (gettimeofday(&tvb, NULL)) + continue; + do { + for (i = 0; i < 1000 * 100; i++) + delaycount = i * i; + if (gettimeofday(&tv, NULL)) + break; + tv.tv_sec -= tvb.tv_sec; + if (tv.tv_sec > 1) + break; + tv.tv_usec += tv.tv_sec * 1000 * 1000; + tv.tv_usec -= tvb.tv_usec; + } while (tv.tv_usec < 1000); + } return 0; } ___EOF___ -gcc -static -Os -o init init.c +cc -static -Os -o init init.c strip init rm init.c echo "Done creating a statically linked C-language initrd"
Signature · 1 line
2.17.1
PATCH 4/8 rcutorture: Add cross-compile capability to initrd.sh
In reply to Paul E. McKenneyFrom: "Paul E. McKenney" <[email protected]>
This adds the CROSS_COMPILE environment to the initrd.sh script's gcc command to enable cross compilation.
Reported-by Willy Tarreau <[email protected]>
Signed-off-by Paul E. McKenney <[email protected]>
--- tools/testing/selftests/rcutorture/bin/mkinitrd.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
tools/testing/selftests/rcutorture/bin/mkinitrd.sh +1 -1
@@ -113,7 +113,7 @@ int main(int argc, int argv[]) return 0; } ___EOF___ -cc -static -Os -o init init.c +${CROSS_COMPILE}gcc -static -Os -o init init.c strip init rm init.c echo "Done creating a statically linked C-language initrd"
Signature · 1 line
2.17.1
PATCH 5/8 rcutorture: Always strip using the cross-compiler
In reply to Paul E. McKenneyFrom: Willy Tarreau <[email protected]>
Strip using -s on the compiler command line instead of calling the "strip" utility as the latter isn't necessarily compatible with the target arch.
Signed-off-by Willy Tarreau <[email protected]>
Signed-off-by Paul E. McKenney <[email protected]>
--- tools/testing/selftests/rcutorture/bin/mkinitrd.sh | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
tools/testing/selftests/rcutorture/bin/mkinitrd.sh +1 -2
@@ -113,8 +113,7 @@ int main(int argc, int argv[]) return 0; } ___EOF___ -${CROSS_COMPILE}gcc -static -Os -o init init.c -strip init +${CROSS_COMPILE}gcc -s -static -Os -o init init.c rm init.c echo "Done creating a statically linked C-language initrd"
Signature · 1 line
2.17.1
PATCH 6/8 rcutorture: Check initrd/init instead of initrd only
In reply to Paul E. McKenneyFrom: Willy Tarreau <[email protected]>
If the build fails, we can end up with an empty initrd directory which prevents the build script from operating again. Better rely on the resulting init executable instead.
Signed-off-by Willy Tarreau <[email protected]>
Signed-off-by Paul E. McKenney <[email protected]>
--- tools/testing/selftests/rcutorture/bin/mkinitrd.sh | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
tools/testing/selftests/rcutorture/bin/mkinitrd.sh +4 -4
@@ -28,8 +28,8 @@ if [ ! -d "$D" ]; then echo >&2 "$D does not exist: Malformed kernel source tree?" exit 1 fi -if [ -d "$D/initrd" ]; then - echo "$D/initrd already exists, no need to create it" +if [ -s "$D/initrd/init" ]; then + echo "$D/initrd/init already exists, no need to create it" exit 0 fi
@@ -65,7 +65,7 @@ then # Filesystem creation dracut --force --no-hostonly --no-hostonly-cmdline --module "base" $T/initramfs.img cd $D - mkdir initrd + mkdir -p initrd cd initrd zcat $T/initramfs.img | cpio -id cp $T/init init
@@ -79,7 +79,7 @@ fi # future-proof than dracut. echo "Could not find dracut, attempting C initrd" cd $D -mkdir initrd +mkdir -p initrd cd initrd cat > init.c << '___EOF___' #include <unistd.h>
Signature · 1 line
2.17.1
PATCH 7/8 rcutorture: Import a copy of nolibc
In reply to Paul E. McKenneyFrom: Willy Tarreau <[email protected]>
This is a definition of the most common syscalls needed in minimalist init executables, allowing to statically build them with no external dependencies. It is sufficient in its current form to build rcutorture's init on x86_64, i386, arm, and arm64. Others have not been ported or tested. Updates may be found here :
http://git.formilux.org/?p=people/willy/nolibc.git
Signed-off-by Willy Tarreau <[email protected]>
Signed-off-by Paul E. McKenney <[email protected]>
--- .../testing/selftests/rcutorture/bin/nolibc.h | 2197 +++++++++++++++++ 1 file changed, 2197 insertions(+) create mode 100644 tools/testing/selftests/rcutorture/bin/nolibc.h
tools/testing/selftests/rcutorture/bin/nolibc.h new file +2197 -0
@@ -0,0 +1,2197 @@ +/* SPDX-License-Identifier: LGPL-2.1 OR MIT */ +/* nolibc.h +* Copyright (C) 2017-2018 Willy Tarreau <[email protected]> +*/ + +/* some archs (at least aarch64) don't expose the regular syscalls anymore by +* default, either because they have an "_at" replacement, or because there are +* more modern alternatives. For now we'd rather still use them. +*/ +#define __ARCH_WANT_SYSCALL_NO_AT +#define __ARCH_WANT_SYSCALL_NO_FLAGS +#define __ARCH_WANT_SYSCALL_DEPRECATED + +#include <asm/unistd.h> +#include <asm/ioctls.h> +#include <asm/errno.h> +#include <linux/fs.h> +#include <linux/loop.h> + +#define NOLIBC + +/* Build a static executable this way : +* $ gcc -fno-asynchronous-unwind-tables -fno-ident -s -Os -nostdlib \ +* -static -include nolibc.h -lgcc -o hello hello.c +* +* Useful calling convention table found here : +* http://man7.org/linux/man-pages/man2/syscall.2.html +* +* This doc is even better : +* https://w3challs.com/syscalls/ +*/ + + +/* this way it will be removed if unused */ +static int errno; + +#ifndef NOLIBC_IGNORE_ERRNO +#define SET_ERRNO (v) do { errno = (v); } while (0) +#else +#define SET_ERRNO (v) do { } while (0) +#endif + +/* errno codes all ensure that they will not conflict with a valid pointer +* because they all correspond to the highest addressable memry page. +*/ +#define MAX_ERRNO 4095 + +/* Declare a few quite common macros and types that usually are in stdlib.h, +* stdint.h, ctype.h, unistd.h and a few other common locations. +*/ + +#define NULL ((void *)0) + +/* stdint types */ +typedef unsigned char uint8_t ; +typedef signed char int8_t ; +typedef unsigned short uint16_t ; +typedef signed short int16_t ; +typedef unsigned int uint32_t ; +typedef signed int int32_t ; +typedef unsigned long long uint64_t ; +typedef signed long long int64_t ; +typedef unsigned long size_t ; +typedef signed long ssize_t ; +typedef unsigned long uintptr_t ; +typedef signed long intptr_t ; +typedef signed long ptrdiff_t ; + +/* for stat() */ +typedef unsigned int dev_t ; +typedef unsigned long ino_t ; +typedef unsigned int mode_t ; +typedef signed int pid_t ; +typedef unsigned int uid_t ; +typedef unsigned int gid_t ; +typedef unsigned long nlink_t ; +typedef signed long off_t ; +typedef signed long blksize_t ; +typedef signed long blkcnt_t ; +typedef signed long time_t ; + +/* for poll() */ +struct pollfd { +int fd; +short int events; +short int revents; +}; + +/* for select() */ +struct timeval { +long tv_sec; +long tv_usec; +}; + +/* for pselect() */ +struct timespec { +long tv_sec; +long tv_nsec; +}; + +/* for gettimeofday() */ +struct timezone { +int tz_minuteswest; +int tz_dsttime; +}; + +/* for getdents64() */ +struct linux_dirent64 { +uint64_t d_ino; +int64_t d_off; +unsigned short d_reclen; +unsigned char d_type; +char d_name[]; +}; + +/* commonly an fd_set represents 256 FDs */ +#define FD_SETSIZE 256 +typedef struct {uint32_t fd32[FD_SETSIZE /32 ]; }fd_set ; + +/* needed by wait4() */ +struct rusage { +struct timeval ru_utime; +struct timeval ru_stime; +long ru_maxrss; +long ru_ixrss; +long ru_idrss; +long ru_isrss; +long ru_minflt; +long ru_majflt; +long ru_nswap; +long ru_inblock; +long ru_oublock; +long ru_msgsnd; +long ru_msgrcv; +long ru_nsignals; +long ru_nvcsw; +long ru_nivcsw; +}; + +/* stat flags (WARNING, octal here) */ +#define S_IFDIR 0040000 +#define S_IFCHR 0020000 +#define S_IFBLK 0060000 +#define S_IFREG 0100000 +#define S_IFIFO 0010000 +#define S_IFLNK 0120000 +#define S_IFSOCK 0140000 +#define S_IFMT 0170000 + +#define S_ISDIR (mode) (((mode) & S_IFDIR) == S_IFDIR) +#define S_ISCHR (mode) (((mode) & S_IFCHR) == S_IFCHR) +#define S_ISBLK (mode) (((mode) & S_IFBLK) == S_IFBLK) +#define S_ISREG (mode) (((mode) & S_IFREG) == S_IFREG) +#define S_ISFIFO (mode) (((mode) & S_IFIFO) == S_IFIFO) +#define S_ISLNK (mode) (((mode) & S_IFLNK) == S_IFLNK) +#define S_ISSOCK (mode) (((mode) & S_IFSOCK) == S_IFSOCK) + +#define DT_UNKNOWN 0 +#define DT_FIFO 1 +#define DT_CHR 2 +#define DT_DIR 4 +#define DT_BLK 6 +#define DT_REG 8 +#define DT_LNK 10 +#define DT_SOCK 12 + +/* all the *at functions */ +#ifndef AT_FDWCD +#define AT_FDCWD -100 +#endif + +/* lseek */ +#define SEEK_SET 0 +#define SEEK_CUR 1 +#define SEEK_END 2 + +/* reboot */ +#define LINUX_REBOOT_MAGIC1 0xfee1dead +#define LINUX_REBOOT_MAGIC2 0x28121969 +#define LINUX_REBOOT_CMD_HALT 0xcdef0123 +#define LINUX_REBOOT_CMD_POWER_OFF 0x4321fedc +#define LINUX_REBOOT_CMD_RESTART 0x01234567 +#define LINUX_REBOOT_CMD_SW_SUSPEND 0xd000fce2 + + +/* The format of the struct as returned by the libc to the application, which +* significantly differs from the format returned by the stat() syscall flavours. +*/ +struct stat { +dev_t st_dev;/* ID of device containing file */ +ino_t st_ino;/* inode number */ +mode_t st_mode;/* protection */ +nlink_t st_nlink;/* number of hard links */ +uid_t st_uid;/* user ID of owner */ +gid_t st_gid;/* group ID of owner */ +dev_t st_rdev;/* device ID (if special file) */ +off_t st_size;/* total size, in bytes */ +blksize_t st_blksize;/* blocksize for file system I/O */ +blkcnt_t st_blocks;/* number of 512B blocks allocated */ +time_t st_atime;/* time of last access */ +time_t st_mtime;/* time of last modification */ +time_t st_ctime;/* time of last status change */ +}; + +#define WEXITSTATUS (status) (((status) & 0xff00) >> 8) +#define WIFEXITED (status) (((status) & 0x7f) == 0) + + +/* Below comes the architecture-specific code. For each architecture, we have +* the syscall declarations and the _start code definition. This is the only +* global part. On all architectures the kernel puts everything in the stack +* before jumping to _start just above us, without any return address (_start +* is not a function but an entry pint). So at the stack pointer we find argc. +* Then argv[] begins, and ends at the first NULL. Then we have envp which +* starts and ends with a NULL as well. So envp=argv+argc+1. +*/ + +#if defined(__x86_64__) +/* Syscalls for x86_64 : +* - registers are 64-bit +* - syscall number is passed in rax +* - arguments are in rdi, rsi, rdx, r10, r8, r9 respectively +* - the system call is performed by calling the syscall instruction +* - syscall return comes in rax +* - rcx and r8..r11 may be clobbered, others are preserved. +* - the arguments are cast to long and assigned into the target registers +* which are then simply passed as registers to the asm code, so that we +* don't have to experience issues with register constraints. +* - the syscall number is always specified last in order to allow to force +* some registers before (gcc refuses a %-register at the last position). +*/ + +#define my_syscall0 (num) \ +({ \ + long _ret; \ + register long _num asm("rax") = (num); \ + \ + asm volatile ( \ + "syscall\n" \ + : "=a" (_ret) \ + : "0"(_num) \ + : "rcx", "r8", "r9", "r10", "r11", "memory", "cc" \ + ); \ + _ret; \ +}) + +#define my_syscall1 (num, arg1) \ +({ \ + long _ret; \ + register long _num asm("rax") = (num); \ + register long _arg1 asm("rdi") = (long)(arg1); \ + \ + asm volatile ( \ + "syscall\n" \ + : "=a" (_ret) \ + : "r"(_arg1), \ + "0"(_num) \ + : "rcx", "r8", "r9", "r10", "r11", "memory", "cc" \ + ); \ + _ret; \ +}) + +#define my_syscall2 (num, arg1, arg2) \ +({ \ + long _ret; \ + register long _num asm("rax") = (num); \ + register long _arg1 asm("rdi") = (long)(arg1); \ + register long _arg2 asm("rsi") = (long)(arg2); \ + \ + asm volatile ( \ + "syscall\n" \ + : "=a" (_ret) \ + : "r"(_arg1), "r"(_arg2), \ + "0"(_num) \ + : "rcx", "r8", "r9", "r10", "r11", "memory", "cc" \ + ); \ + _ret; \ +}) + +#define my_syscall3 (num, arg1, arg2, arg3) \ +({ \ + long _ret; \ + register long _num asm("rax") = (num); \ + register long _arg1 asm("rdi") = (long)(arg1); \ + register long _arg2 asm("rsi") = (long)(arg2); \ + register long _arg3 asm("rdx") = (long)(arg3); \ + \ + asm volatile ( \ + "syscall\n" \ + : "=a" (_ret) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), \ + "0"(_num) \ + : "rcx", "r8", "r9", "r10", "r11", "memory", "cc" \ + ); \ + _ret; \ +}) + +#define my_syscall4 (num, arg1, arg2, arg3, arg4) \ +({ \ + long _ret; \ + register long _num asm("rax") = (num); \ + register long _arg1 asm("rdi") = (long)(arg1); \ + register long _arg2 asm("rsi") = (long)(arg2); \ + register long _arg3 asm("rdx") = (long)(arg3); \ + register long _arg4 asm("r10") = (long)(arg4); \ + \ + asm volatile ( \ + "syscall\n" \ + : "=a" (_ret), "=r"(_arg4) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), \ + "0"(_num) \ + : "rcx", "r8", "r9", "r11", "memory", "cc" \ + ); \ + _ret; \ +}) + +#define my_syscall5 (num, arg1, arg2, arg3, arg4, arg5) \ +({ \ + long _ret; \ + register long _num asm("rax") = (num); \ + register long _arg1 asm("rdi") = (long)(arg1); \ + register long _arg2 asm("rsi") = (long)(arg2); \ + register long _arg3 asm("rdx") = (long)(arg3); \ + register long _arg4 asm("r10") = (long)(arg4); \ + register long _arg5 asm("r8") = (long)(arg5); \ + \ + asm volatile ( \ + "syscall\n" \ + : "=a" (_ret), "=r"(_arg4), "=r"(_arg5) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), "r"(_arg5), \ + "0"(_num) \ + : "rcx", "r9", "r11", "memory", "cc" \ + ); \ + _ret; \ +}) + +#define my_syscall6 (num, arg1, arg2, arg3, arg4, arg5, arg6) \ +({ \ + long _ret; \ + register long _num asm("rax") = (num); \ + register long _arg1 asm("rdi") = (long)(arg1); \ + register long _arg2 asm("rsi") = (long)(arg2); \ + register long _arg3 asm("rdx") = (long)(arg3); \ + register long _arg4 asm("r10") = (long)(arg4); \ + register long _arg5 asm("r8") = (long)(arg5); \ + register long _arg6 asm("r9") = (long)(arg6); \ + \ + asm volatile ( \ + "syscall\n" \ + : "=a" (_ret), "=r"(_arg4), "=r"(_arg5) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), "r"(_arg5), \ + "r"(_arg6), "0"(_num) \ + : "rcx", "r11", "memory", "cc" \ + ); \ + _ret; \ +}) + +/* startup code */ +asm(".section .text\n" +".global _start\n" +"_start:\n" +"pop %rdi\n" // argc (first arg, %rdi) +"mov %rsp, %rsi\n" // argv[] (second arg, %rsi) +"lea 8(%rsi,%rdi,8),%rdx\n" // then a NULL then envp (third arg, %rdx) +"and $-16, %rsp\n" // x86 ABI : esp must be 16-byte aligned when +"sub $8, %rsp\n" // entering the callee +"call main\n" // main() returns the status code, we'll exit with it. +"movzb %al, %rdi\n" // retrieve exit code from 8 lower bits +"mov $60, %rax\n" // NR_exit == 60 +"syscall\n" // really exit +"hlt\n" // ensure it does not return +"" ); + +/* fcntl / open */ +#define O_RDONLY 0 +#define O_WRONLY 1 +#define O_RDWR 2 +#define O_CREAT 0x40 +#define O_EXCL 0x80 +#define O_NOCTTY 0x100 +#define O_TRUNC 0x200 +#define O_APPEND 0x400 +#define O_NONBLOCK 0x800 +#define O_DIRECTORY 0x10000 + +/* The struct returned by the stat() syscall, equivalent to stat64(). The +* syscall returns 116 bytes and stops in the middle of __unused. +*/ +struct sys_stat_struct { +unsigned long st_dev; +unsigned long st_ino; +unsigned long st_nlink; +unsigned int st_mode; +unsigned int st_uid; + +unsigned int st_gid; +unsigned int __pad0; +unsigned long st_rdev; +long st_size; +long st_blksize; + +long st_blocks; +unsigned long st_atime; +unsigned long st_atime_nsec; +unsigned long st_mtime; + +unsigned long st_mtime_nsec; +unsigned long st_ctime; +unsigned long st_ctime_nsec; +long __unused[3 ]; +}; + +#elif defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__) +/* Syscalls for i386 : +* - mostly similar to x86_64 +* - registers are 32-bit +* - syscall number is passed in eax +* - arguments are in ebx, ecx, edx, esi, edi, ebp respectively +* - all registers are preserved (except eax of course) +* - the system call is performed by calling int $0x80 +* - syscall return comes in eax +* - the arguments are cast to long and assigned into the target registers +* which are then simply passed as registers to the asm code, so that we +* don't have to experience issues with register constraints. +* - the syscall number is always specified last in order to allow to force +* some registers before (gcc refuses a %-register at the last position). +* +* Also, i386 supports the old_select syscall if newselect is not available +*/ +#define __ARCH_WANT_SYS_OLD_SELECT + +#define my_syscall0 (num) \ +({ \ + long _ret; \ + register long _num asm("eax") = (num); \ + \ + asm volatile ( \ + "int $0x80\n" \ + : "=a" (_ret) \ + : "0"(_num) \ + : "memory", "cc" \ + ); \ + _ret; \ +}) + +#define my_syscall1 (num, arg1) \ +({ \ + long _ret; \ + register long _num asm("eax") = (num); \ + register long _arg1 asm("ebx") = (long)(arg1); \ + \ + asm volatile ( \ + "int $0x80\n" \ + : "=a" (_ret) \ + : "r"(_arg1), \ + "0"(_num) \ + : "memory", "cc" \ + ); \ + _ret; \ +}) + +#define my_syscall2 (num, arg1, arg2) \ +({ \ + long _ret; \ + register long _num asm("eax") = (num); \ + register long _arg1 asm("ebx") = (long)(arg1); \ + register long _arg2 asm("ecx") = (long)(arg2); \ + \ + asm volatile ( \ + "int $0x80\n" \ + : "=a" (_ret) \ + : "r"(_arg1), "r"(_arg2), \ + "0"(_num) \ + : "memory", "cc" \ + ); \ + _ret; \ +}) + +#define my_syscall3 (num, arg1, arg2, arg3) \ +({ \ + long _ret; \ + register long _num asm("eax") = (num); \ + register long _arg1 asm("ebx") = (long)(arg1); \ + register long _arg2 asm("ecx") = (long)(arg2); \ + register long _arg3 asm("edx") = (long)(arg3); \ + \ + asm volatile ( \ + "int $0x80\n" \ + : "=a" (_ret) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), \ + "0"(_num) \ + : "memory", "cc" \ + ); \ + _ret; \ +}) + +#define my_syscall4 (num, arg1, arg2, arg3, arg4) \ +({ \ + long _ret; \ + register long _num asm("eax") = (num); \ + register long _arg1 asm("ebx") = (long)(arg1); \ + register long _arg2 asm("ecx") = (long)(arg2); \ + register long _arg3 asm("edx") = (long)(arg3); \ + register long _arg4 asm("esi") = (long)(arg4); \ + \ + asm volatile ( \ + "int $0x80\n" \ + : "=a" (_ret) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), \ + "0"(_num) \ + : "memory", "cc" \ + ); \ + _ret; \ +}) + +#define my_syscall5 (num, arg1, arg2, arg3, arg4, arg5) \ +({ \ + long _ret; \ + register long _num asm("eax") = (num); \ + register long _arg1 asm("ebx") = (long)(arg1); \ + register long _arg2 asm("ecx") = (long)(arg2); \ + register long _arg3 asm("edx") = (long)(arg3); \ + register long _arg4 asm("esi") = (long)(arg4); \ + register long _arg5 asm("edi") = (long)(arg5); \ + \ + asm volatile ( \ + "int $0x80\n" \ + : "=a" (_ret) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), "r"(_arg5), \ + "0"(_num) \ + : "memory", "cc" \ + ); \ + _ret; \ +}) + +/* startup code */ +asm(".section .text\n" +".global _start\n" +"_start:\n" +"pop %eax\n" // argc (first arg, %eax) +"mov %esp, %ebx\n" // argv[] (second arg, %ebx) +"lea 4(%ebx,%eax,4),%ecx\n" // then a NULL then envp (third arg, %ecx) +"and $-16, %esp\n" // x86 ABI : esp must be 16-byte aligned when +"push %ecx\n" // push all registers on the stack so that we +"push %ebx\n" // support both regparm and plain stack modes +"push %eax\n" +"call main\n" // main() returns the status code in %eax +"movzbl %al, %ebx\n" // retrieve exit code from lower 8 bits +"movl $1, %eax\n" // NR_exit == 1 +"int $0x80\n" // exit now +"hlt\n" // ensure it does not +"" ); + +/* fcntl / open */ +#define O_RDONLY 0 +#define O_WRONLY 1 +#define O_RDWR 2 +#define O_CREAT 0x40 +#define O_EXCL 0x80 +#define O_NOCTTY 0x100 +#define O_TRUNC 0x200 +#define O_APPEND 0x400 +#define O_NONBLOCK 0x800 +#define O_DIRECTORY 0x10000 + +/* The struct returned by the stat() syscall, 32-bit only, the syscall returns +* exactly 56 bytes (stops before the unused array). +*/ +struct sys_stat_struct { +unsigned long st_dev; +unsigned long st_ino; +unsigned short st_mode; +unsigned short st_nlink; +unsigned short st_uid; +unsigned short st_gid; + +unsigned long st_rdev; +unsigned long st_size; +unsigned long st_blksize; +unsigned long st_blocks; + +unsigned long st_atime; +unsigned long st_atime_nsec; +unsigned long st_mtime; +unsigned long st_mtime_nsec; + +unsigned long st_ctime; +unsigned long st_ctime_nsec; +unsigned long __unused[2 ]; +}; + +#elif defined(__ARM_EABI__) +/* Syscalls for ARM in ARM or Thumb modes : +* - registers are 32-bit +* - stack is 8-byte aligned +* ( http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.faqs/ka4127.html) +* - syscall number is passed in r7 +* - arguments are in r0, r1, r2, r3, r4, r5 +* - the system call is performed by calling svc #0 +* - syscall return comes in r0. +* - only lr is clobbered. +* - the arguments are cast to long and assigned into the target registers +* which are then simply passed as registers to the asm code, so that we +* don't have to experience issues with register constraints. +* - the syscall number is always specified last in order to allow to force +* some registers before (gcc refuses a %-register at the last position). +* +* Also, ARM supports the old_select syscall if newselect is not available +*/ +#define __ARCH_WANT_SYS_OLD_SELECT + +#define my_syscall0 (num) \ +({ \ + register long _num asm("r7") = (num); \ + register long _arg1 asm("r0"); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r"(_arg1) \ + : "r"(_num) \ + : "memory", "cc", "lr" \ + ); \ + _arg1; \ +}) + +#define my_syscall1 (num, arg1) \ +({ \ + register long _num asm("r7") = (num); \ + register long _arg1 asm("r0") = (long)(arg1); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r"(_arg1) \ + : "r"(_arg1), \ + "r"(_num) \ + : "memory", "cc", "lr" \ + ); \ + _arg1; \ +}) + +#define my_syscall2 (num, arg1, arg2) \ +({ \ + register long _num asm("r7") = (num); \ + register long _arg1 asm("r0") = (long)(arg1); \ + register long _arg2 asm("r1") = (long)(arg2); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r"(_arg1) \ + : "r"(_arg1), "r"(_arg2), \ + "r"(_num) \ + : "memory", "cc", "lr" \ + ); \ + _arg1; \ +}) + +#define my_syscall3 (num, arg1, arg2, arg3) \ +({ \ + register long _num asm("r7") = (num); \ + register long _arg1 asm("r0") = (long)(arg1); \ + register long _arg2 asm("r1") = (long)(arg2); \ + register long _arg3 asm("r2") = (long)(arg3); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r"(_arg1) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), \ + "r"(_num) \ + : "memory", "cc", "lr" \ + ); \ + _arg1; \ +}) + +#define my_syscall4 (num, arg1, arg2, arg3, arg4) \ +({ \ + register long _num asm("r7") = (num); \ + register long _arg1 asm("r0") = (long)(arg1); \ + register long _arg2 asm("r1") = (long)(arg2); \ + register long _arg3 asm("r2") = (long)(arg3); \ + register long _arg4 asm("r3") = (long)(arg4); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r"(_arg1) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), \ + "r"(_num) \ + : "memory", "cc", "lr" \ + ); \ + _arg1; \ +}) + +#define my_syscall5 (num, arg1, arg2, arg3, arg4, arg5) \ +({ \ + register long _num asm("r7") = (num); \ + register long _arg1 asm("r0") = (long)(arg1); \ + register long _arg2 asm("r1") = (long)(arg2); \ + register long _arg3 asm("r2") = (long)(arg3); \ + register long _arg4 asm("r3") = (long)(arg4); \ + register long _arg5 asm("r4") = (long)(arg5); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r" (_arg1) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), "r"(_arg5), \ + "r"(_num) \ + : "memory", "cc", "lr" \ + ); \ + _arg1; \ +}) + +/* startup code */ +asm(".section .text\n" + ".global _start\n" + "_start:\n" +#if defined(__THUMBEB__) || defined(__THUMBEL__) +/* We enter here in 32-bit mode but if some previous functions were in +* 16-bit mode, the assembler cannot know, so we need to tell it we're in +* 32-bit now, then switch to 16-bit (is there a better way to do it than +* adding 1 by hand ?) and tell the asm we're now in 16-bit mode so that +* it generates correct instructions. Note that we do not support thumb1. +*/ +".code 32\n" +"add r0, pc, #1\n" +"bx r0\n" + ".code 16\n" +#endif +"pop {%r0}\n" // argc was in the stack +"mov %r1, %sp\n" // argv = sp +"add %r2, %r1, %r0, lsl #2\n" // envp = argv + 4*argc ... +"add %r2, %r2, $4\n" // ... + 4 +"and %r3, %r1, $-8\n" // AAPCS : sp must be 8-byte aligned in the +"mov %sp, %r3\n" // callee, an bl doesn't push (lr=pc) +"bl main\n" // main() returns the status code, we'll exit with it. +"and %r0, %r0, $0xff\n" // limit exit code to 8 bits +"movs r7, $1\n" // NR_exit == 1 +"svc $0x00\n" + ""); + +/* fcntl / open */ +#define O_RDONLY 0 +#define O_WRONLY 1 +#define O_RDWR 2 +#define O_CREAT 0x40 +#define O_EXCL 0x80 +#define O_NOCTTY 0x100 +#define O_TRUNC 0x200 +#define O_APPEND 0x400 +#define O_NONBLOCK 0x800 +#define O_DIRECTORY 0x4000 + +/* The struct returned by the stat() syscall, 32-bit only, the syscall returns +* exactly 56 bytes (stops before the unused array). In big endian, the format +* differs as devices are returned as short only. +*/ +struct sys_stat_struct { +#if defined(__ARMEB__) +unsigned short st_dev; +unsigned short __pad1; +#else +unsigned long st_dev; +#endif +unsigned long st_ino; +unsigned short st_mode; +unsigned short st_nlink; +unsigned short st_uid; +unsigned short st_gid; +#if defined(__ARMEB__) +unsigned short st_rdev; +unsigned short __pad2; +#else +unsigned long st_rdev; +#endif +unsigned long st_size; +unsigned long st_blksize; +unsigned long st_blocks; +unsigned long st_atime; +unsigned long st_atime_nsec; +unsigned long st_mtime; +unsigned long st_mtime_nsec; +unsigned long st_ctime; +unsigned long st_ctime_nsec; +unsigned long __unused[2 ]; +}; + +#elif defined(__aarch64__) +/* Syscalls for AARCH64 : +* - registers are 64-bit +* - stack is 16-byte aligned +* - syscall number is passed in x8 +* - arguments are in x0, x1, x2, x3, x4, x5 +* - the system call is performed by calling svc 0 +* - syscall return comes in x0. +* - the arguments are cast to long and assigned into the target registers +* which are then simply passed as registers to the asm code, so that we +* don't have to experience issues with register constraints. +* +* On aarch64, select() is not implemented so we have to use pselect6(). +*/ +#define __ARCH_WANT_SYS_PSELECT6 + +#define my_syscall0 (num) \ +({ \ + register long _num asm("x8") = (num); \ + register long _arg1 asm("x0"); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r"(_arg1) \ + : "r"(_num) \ + : "memory", "cc" \ + ); \ + _arg1; \ +}) + +#define my_syscall1 (num, arg1) \ +({ \ + register long _num asm("x8") = (num); \ + register long _arg1 asm("x0") = (long)(arg1); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r"(_arg1) \ + : "r"(_arg1), \ + "r"(_num) \ + : "memory", "cc" \ + ); \ + _arg1; \ +}) + +#define my_syscall2 (num, arg1, arg2) \ +({ \ + register long _num asm("x8") = (num); \ + register long _arg1 asm("x0") = (long)(arg1); \ + register long _arg2 asm("x1") = (long)(arg2); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r"(_arg1) \ + : "r"(_arg1), "r"(_arg2), \ + "r"(_num) \ + : "memory", "cc" \ + ); \ + _arg1; \ +}) + +#define my_syscall3 (num, arg1, arg2, arg3) \ +({ \ + register long _num asm("x8") = (num); \ + register long _arg1 asm("x0") = (long)(arg1); \ + register long _arg2 asm("x1") = (long)(arg2); \ + register long _arg3 asm("x2") = (long)(arg3); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r"(_arg1) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), \ + "r"(_num) \ + : "memory", "cc" \ + ); \ + _arg1; \ +}) + +#define my_syscall4 (num, arg1, arg2, arg3, arg4) \ +({ \ + register long _num asm("x8") = (num); \ + register long _arg1 asm("x0") = (long)(arg1); \ + register long _arg2 asm("x1") = (long)(arg2); \ + register long _arg3 asm("x2") = (long)(arg3); \ + register long _arg4 asm("x3") = (long)(arg4); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r"(_arg1) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), \ + "r"(_num) \ + : "memory", "cc" \ + ); \ + _arg1; \ +}) + +#define my_syscall5 (num, arg1, arg2, arg3, arg4, arg5) \ +({ \ + register long _num asm("x8") = (num); \ + register long _arg1 asm("x0") = (long)(arg1); \ + register long _arg2 asm("x1") = (long)(arg2); \ + register long _arg3 asm("x2") = (long)(arg3); \ + register long _arg4 asm("x3") = (long)(arg4); \ + register long _arg5 asm("x4") = (long)(arg5); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r" (_arg1) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), "r"(_arg5), \ + "r"(_num) \ + : "memory", "cc" \ + ); \ + _arg1; \ +}) + +#define my_syscall6 (num, arg1, arg2, arg3, arg4, arg5, arg6) \ +({ \ + register long _num asm("x8") = (num); \ + register long _arg1 asm("x0") = (long)(arg1); \ + register long _arg2 asm("x1") = (long)(arg2); \ + register long _arg3 asm("x2") = (long)(arg3); \ + register long _arg4 asm("x3") = (long)(arg4); \ + register long _arg5 asm("x4") = (long)(arg5); \ + register long _arg6 asm("x5") = (long)(arg6); \ + \ + asm volatile ( \ + "svc #0\n" \ + : "=r" (_arg1) \ + : "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), "r"(_arg5), \ + "r"(_arg6), "r"(_num) \ + : "memory", "cc" \ + ); \ + _arg1; \ +}) + +/* startup code */ +asm(".section .text\n" +".global _start\n" +"_start:\n" +"ldr x0, [sp]\n" // argc (x0) was in the stack +"add x1, sp, 8\n" // argv (x1) = sp +"lsl x2, x0, 3\n" // envp (x2) = 8*argc ... +"add x2, x2, 8\n" // + 8 (skip null) +"add x2, x2, x1\n" // + argv +"and sp, x1, -16\n" // sp must be 16-byte aligned in the callee +"bl main\n" // main() returns the status code, we'll exit with it. +"and x0, x0, 0xff\n" // limit exit code to 8 bits +"mov x8, 93\n" // NR_exit == 93 +"svc #0\n" +"" ); + +/* fcntl / open */ +#define O_RDONLY 0 +#define O_WRONLY 1 +#define O_RDWR 2 +#define O_CREAT 0x40 +#define O_EXCL 0x80 +#define O_NOCTTY 0x100 +#define O_TRUNC 0x200 +#define O_APPEND 0x400 +#define O_NONBLOCK 0x800 +#define O_DIRECTORY 0x4000 + +/* The struct returned by the newfstatat() syscall. Differs slightly from the +* x86_64's stat one by field ordering, so be careful. +*/ +struct sys_stat_struct { +unsigned long st_dev; +unsigned long st_ino; +unsigned int st_mode; +unsigned int st_nlink; +unsigned int st_uid; +unsigned int st_gid; + +unsigned long st_rdev; +unsigned long __pad1; +long st_size; +int st_blksize; +int __pad2; + +long st_blocks; +long st_atime; +unsigned long st_atime_nsec; +long st_mtime; + +unsigned long st_mtime_nsec; +long st_ctime; +unsigned long st_ctime_nsec; +unsigned int __unused[2 ]; +}; + +#elif defined(__mips__) && defined(_ABIO32) +/* Syscalls for MIPS ABI O32 : +* - WARNING! there's always a delayed slot! +* - WARNING again, the syntax is different, registers take a '$' and numbers +* do not. +* - registers are 32-bit +* - stack is 8-byte aligned +* - syscall number is passed in v0 (starts at 0xfa0). +* - arguments are in a0, a1, a2, a3, then the stack. The caller needs to +* leave some room in the stack for the callee to save a0..a3 if needed. +* - Many registers are clobbered, in fact only a0..a2 and s0..s8 are +* preserved. See: https://www.linux-mips.org/wiki/Syscall as well as +* scall32-o32.S in the kernel sources. +* - the system call is performed by calling "syscall" +* - syscall return comes in v0, and register a3 needs to be checked to know +* if an error occured, in which case errno is in v0. +* - the arguments are cast to long and assigned into the target registers +* which are then simply passed as registers to the asm code, so that we +* don't have to experience issues with register constraints. +*/ + +#define my_syscall0 (num) \ +({ \ + register long _num asm("v0") = (num); \ + register long _arg4 asm("a3"); \ + \ + asm volatile ( \ + "addiu $sp, $sp, -32\n" \ + "syscall\n" \ + "addiu $sp, $sp, 32\n" \ + : "=r"(_num), "=r"(_arg4) \ + : "r"(_num) \ + : "memory", "cc", "at", "v1", "hi", "lo", \ + \ + ); \ + _arg4 ? -_num : _num; \ +}) + +#define my_syscall1 (num, arg1) \ +({ \ + register long _num asm("v0") = (num); \ + register long _arg1 asm("a0") = (long)(arg1); \ + register long _arg4 asm("a3"); \ + \ + asm volatile ( \ + "addiu $sp, $sp, -32\n" \ + "syscall\n" \ + "addiu $sp, $sp, 32\n" \ + : "=r"(_num), "=r"(_arg4) \ + : "0"(_num), \ + "r"(_arg1) \ + : "memory", "cc", "at", "v1", "hi", "lo", \ + \ + ); \ + _arg4 ? -_num : _num; \ +}) + +#define my_syscall2 (num, arg1, arg2) \ +({ \ + register long _num asm("v0") = (num); \ + register long _arg1 asm("a0") = (long)(arg1); \ + register long _arg2 asm("a1") = (long)(arg2); \ + register long _arg4 asm("a3"); \ + \ + asm volatile ( \ + "addiu $sp, $sp, -32\n" \ + "syscall\n" \ + "addiu $sp, $sp, 32\n" \ + : "=r"(_num), "=r"(_arg4) \ + : "0"(_num), \ + "r"(_arg1), "r"(_arg2) \ + : "memory", "cc", "at", "v1", "hi", "lo", \ + \ + ); \ + _arg4 ? -_num : _num; \ +}) + +#define my_syscall3 (num, arg1, arg2, arg3) \ +({ \ + register long _num asm("v0") = (num); \ + register long _arg1 asm("a0") = (long)(arg1); \ + register long _arg2 asm("a1") = (long)(arg2); \ + register long _arg3 asm("a2") = (long)(arg3); \ + register long _arg4 asm("a3"); \ + \ + asm volatile ( \ + "addiu $sp, $sp, -32\n" \ + "syscall\n" \ + "addiu $sp, $sp, 32\n" \ + : "=r"(_num), "=r"(_arg4) \ + : "0"(_num), \ + "r"(_arg1), "r"(_arg2), "r"(_arg3) \ + : "memory", "cc", "at", "v1", "hi", "lo", \ + \ + ); \ + _arg4 ? -_num : _num; \ +}) + +#define my_syscall4 (num, arg1, arg2, arg3, arg4) \ +({ \ + register long _num asm("v0") = (num); \ + register long _arg1 asm("a0") = (long)(arg1); \ + register long _arg2 asm("a1") = (long)(arg2); \ + register long _arg3 asm("a2") = (long)(arg3); \ + register long _arg4 asm("a3") = (long)(arg4); \ + \ + asm volatile ( \ + "addiu $sp, $sp, -32\n" \ + "syscall\n" \ + "addiu $sp, $sp, 32\n" \ + : "=r" (_num), "=r"(_arg4) \ + : "0"(_num), \ + "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4) \ + : "memory", "cc", "at", "v1", "hi", "lo", \ + \ + ); \ + _arg4 ? -_num : _num; \ +}) + +#define my_syscall5 (num, arg1, arg2, arg3, arg4, arg5) \ +({ \ + register long _num asm("v0") = (num); \ + register long _arg1 asm("a0") = (long)(arg1); \ + register long _arg2 asm("a1") = (long)(arg2); \ + register long _arg3 asm("a2") = (long)(arg3); \ + register long _arg4 asm("a3") = (long)(arg4); \ + register long _arg5 = (long)(arg5); \ + \ + asm volatile ( \ + "addiu $sp, $sp, -32\n" \ + "sw %7, 16($sp)\n" \ + "syscall\n " \ + "addiu $sp, $sp, 32\n" \ + : "=r" (_num), "=r"(_arg4) \ + : "0"(_num), \ + "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), "r"(_arg5) \ + : "memory", "cc", "at", "v1", "hi", "lo", \ + \ + ); \ + _arg4 ? -_num : _num; \ +}) + +/* startup code, note that it's called __start on MIPS */ +asm(".section .text\n" +".set nomips16\n" +".global __start\n" +".set noreorder\n" +".option pic0\n" +".ent __start\n" +"__start:\n" +"lw $a0,($sp)\n" // argc was in the stack +"addiu $a1, $sp, 4\n" // argv = sp + 4 +"sll $a2, $a0, 2\n" // a2 = argc * 4 +"add $a2, $a2, $a1\n" // envp = argv + 4*argc ... +"addiu $a2, $a2, 4\n" // ... + 4 +"li $t0, -8\n" +"and $sp, $sp, $t0\n" // sp must be 8-byte aligned +"addiu $sp,$sp,-16\n" // the callee expects to save a0..a3 there! +"jal main\n" // main() returns the status code, we'll exit with it. +"nop\n" // delayed slot +"and $a0, $v0, 0xff\n" // limit exit code to 8 bits +"li $v0, 4001\n" // NR_exit == 4001 +"syscall\n" +".end __start\n" +"" ); + +/* fcntl / open */ +#define O_RDONLY 0 +#define O_WRONLY 1 +#define O_RDWR 2 +#define O_APPEND 0x0008 +#define O_NONBLOCK 0x0080 +#define O_CREAT 0x0100 +#define O_TRUNC 0x0200 +#define O_EXCL 0x0400 +#define O_NOCTTY 0x0800 +#define O_DIRECTORY 0x10000 + +/* The struct returned by the stat() syscall. 88 bytes are returned by the +* syscall. +*/ +struct sys_stat_struct { +unsigned int st_dev; +long st_pad1[3 ]; +unsigned long st_ino; +unsigned int st_mode; +unsigned int st_nlink; +unsigned int st_uid; +unsigned int st_gid; +unsigned int st_rdev; +long st_pad2[2 ]; +long st_size; +long st_pad3; +long st_atime; +long st_atime_nsec; +long st_mtime; +long st_mtime_nsec; +long st_ctime; +long st_ctime_nsec; +long st_blksize; +long st_blocks; +long st_pad4[14 ]; +}; + +#endif + + +/* Below are the C functions used to declare the raw syscalls. They try to be +* architecture-agnostic, and return either a success or -errno. Declaring them +* static will lead to them being inlined in most cases, but it's still possible +* to reference them by a pointer if needed. +*/ +static __attribute__((unused)) +void *sys_brk (void *addr) +{ +return (void *)my_syscall1 (__NR_brk, addr); +} + +static __attribute__((noreturn,unused)) +void sys_exit (int status) +{ +my_syscall1 (__NR_exit, status &255 ); +while (1 );// shut the "noreturn" warnings. +} + +static __attribute__((unused)) +int sys_chdir (const char *path) +{ +return my_syscall1 (__NR_chdir, path); +} + +static __attribute__((unused)) +int sys_chmod (const char *path,mode_t mode) +{ +#ifdef __NR_fchmodat +return my_syscall4 (__NR_fchmodat,AT_FDCWD , path, mode,0 ); +#else +return my_syscall2 (__NR_chmod, path, mode); +#endif +} + +static __attribute__((unused)) +int sys_chown (const char *path,uid_t owner,gid_t group) +{ +#ifdef __NR_fchownat +return my_syscall5 (__NR_fchownat,AT_FDCWD , path, owner, group,0 ); +#else +return my_syscall3 (__NR_chown, path, owner, group); +#endif +} + +static __attribute__((unused)) +int sys_chroot (const char *path) +{ +return my_syscall1 (__NR_chroot, path); +} + +static __attribute__((unused)) +int sys_close (int fd) +{ +return my_syscall1 (__NR_close, fd); +} + +static __attribute__((unused)) +int sys_dup (int fd) +{ +return my_syscall1 (__NR_dup, fd); +} + +static __attribute__((unused)) +int sys_dup2 (int old,int new) +{ +return my_syscall2 (__NR_dup2, old, new); +} + +static __attribute__((unused)) +int sys_execve (const char *filename,char *const argv[],char *const envp[]) +{ +return my_syscall3 (__NR_execve, filename, argv, envp); +} + +static __attribute__((unused)) +pid_t sys_fork (void ) +{ +return my_syscall0 (__NR_fork); +} + +static __attribute__((unused)) +int sys_fsync (int fd) +{ +return my_syscall1 (__NR_fsync, fd); +} + +static __attribute__((unused)) +int sys_getdents64 (int fd,struct linux_dirent64 *dirp,int count) +{ +return my_syscall3 (__NR_getdents64, fd, dirp, count); +} + +static __attribute__((unused)) +pid_t sys_getpgrp (void ) +{ +return my_syscall0 (__NR_getpgrp); +} + +static __attribute__((unused)) +pid_t sys_getpid (void ) +{ +return my_syscall0 (__NR_getpid); +} + +static __attribute__((unused)) +int sys_gettimeofday (struct timeval *tv,struct timezone *tz) +{ +return my_syscall2 (__NR_gettimeofday, tv, tz); +} + +static __attribute__((unused)) +int sys_ioctl (int fd,unsigned long req,void *value) +{ +return my_syscall3 (__NR_ioctl, fd, req, value); +} + +static __attribute__((unused)) +int sys_kill (pid_t pid,int signal) +{ +return my_syscall2 (__NR_kill, pid, signal); +} + +static __attribute__((unused)) +int sys_link (const char *old,const char *new) +{ +#ifdef __NR_linkat +return my_syscall5 (__NR_linkat,AT_FDCWD , old,AT_FDCWD , new,0 ); +#else +return my_syscall2 (__NR_link, old, new); +#endif +} + +static __attribute__((unused)) +off_t sys_lseek (int fd,off_t offset,int whence) +{ +return my_syscall3 (__NR_lseek, fd, offset, whence); +} + +static __attribute__((unused)) +int sys_mkdir (const char *path,mode_t mode) +{ +#ifdef __NR_mkdirat +return my_syscall3 (__NR_mkdirat,AT_FDCWD , path, mode); +#else +return my_syscall2 (__NR_mkdir, path, mode); +#endif +} + +static __attribute__((unused)) +long sys_mknod (const char *path,mode_t mode,dev_t dev) +{ +#ifdef __NR_mknodat +return my_syscall4 (__NR_mknodat,AT_FDCWD , path, mode, dev); +#else +return my_syscall3 (__NR_mknod, path, mode, dev); +#endif +} + +static __attribute__((unused)) +int sys_mount (const char *src,const char *tgt,const char *fst, +unsigned long flags,const void *data) +{ +return my_syscall5 (__NR_mount, src, tgt, fst, flags, data); +} + +static __attribute__((unused)) +int sys_open (const char *path,int flags,mode_t mode) +{ +#ifdef __NR_openat +return my_syscall4 (__NR_openat,AT_FDCWD , path, flags, mode); +#else +return my_syscall3 (__NR_open, path, flags, mode); +#endif +} + +static __attribute__((unused)) +int sys_pivot_root (const char *new,const char *old) +{ +return my_syscall2 (__NR_pivot_root, new, old); +} + +static __attribute__((unused)) +int sys_poll (struct pollfd *fds,int nfds,int timeout) +{ +return my_syscall3 (__NR_poll, fds, nfds, timeout); +} + +static __attribute__((unused)) +ssize_t sys_read (int fd,void *buf,size_t count) +{ +return my_syscall3 (__NR_read, fd, buf, count); +} + +static __attribute__((unused)) +ssize_t sys_reboot (int magic1,int magic2,int cmd,void *arg) +{ +return my_syscall4 (__NR_reboot, magic1, magic2, cmd, arg); +} + +static __attribute__((unused)) +int sys_sched_yield (void ) +{ +return my_syscall0 (__NR_sched_yield); +} + +static __attribute__((unused)) +int sys_select (int nfds,fd_set *rfds,fd_set *wfds,fd_set *efds,struct timeval *timeout) +{ +#if defined(__ARCH_WANT_SYS_OLD_SELECT) && !defined(__NR__newselect) +struct sel_arg_struct { +unsigned long n; +fd_set *r, *w, *e; +struct timeval *t; + } arg = { .n = nfds, .r = rfds, .w = wfds, .e = efds, .t = timeout }; +return my_syscall1 (__NR_select, &arg); +#elif defined(__ARCH_WANT_SYS_PSELECT6) && defined(__NR_pselect6) +struct timespec t; + +if (timeout) { + t.tv_sec = timeout->tv_sec; + t.tv_nsec = timeout->tv_usec *1000 ; + } +return my_syscall6 (__NR_pselect6, nfds, rfds, wfds, efds, timeout ? &t :NULL ,NULL ); +#else +#ifndef __NR__newselect +#define __NR__newselect __NR_select +#endif +return my_syscall5 (__NR__newselect, nfds, rfds, wfds, efds, timeout); +#endif +} + +static __attribute__((unused)) +int sys_setpgid (pid_t pid,pid_t pgid) +{ +return my_syscall2 (__NR_setpgid, pid, pgid); +} + +static __attribute__((unused)) +pid_t sys_setsid (void ) +{ +return my_syscall0 (__NR_setsid); +} + +static __attribute__((unused)) +int sys_stat (const char *path,struct stat *buf) +{ +struct sys_stat_struct stat; +long ret; + +#ifdef __NR_newfstatat +/* only solution for arm64 */ + ret =my_syscall4 (__NR_newfstatat,AT_FDCWD , path, &stat,0 ); +#else + ret =my_syscall2 (__NR_stat, path, &stat); +#endif + buf->st_dev = stat.st_dev; + buf->st_ino = stat.st_ino; + buf->st_mode = stat.st_mode; + buf->st_nlink = stat.st_nlink; + buf->st_uid = stat.st_uid; + buf->st_gid = stat.st_gid; + buf->st_rdev = stat.st_rdev; + buf->st_size = stat.st_size; + buf->st_blksize = stat.st_blksize; + buf->st_blocks = stat.st_blocks; + buf->st_atime = stat.st_atime; + buf->st_mtime = stat.st_mtime; + buf->st_ctime = stat.st_ctime; +return ret; +} + + +static __attribute__((unused)) +int sys_symlink (const char *old,const char *new) +{ +#ifdef __NR_symlinkat +return my_syscall3 (__NR_symlinkat, old,AT_FDCWD , new); +#else +return my_syscall2 (__NR_symlink, old, new); +#endif +} + +static __attribute__((unused)) +mode_t sys_umask (mode_t mode) +{ +return my_syscall1 (__NR_umask, mode); +} + +static __attribute__((unused)) +int sys_umount2 (const char *path,int flags) +{ +return my_syscall2 (__NR_umount2, path, flags); +} + +static __attribute__((unused)) +int sys_unlink (const char *path) +{ +#ifdef __NR_unlinkat +return my_syscall3 (__NR_unlinkat,AT_FDCWD , path,0 ); +#else +return my_syscall1 (__NR_unlink, path); +#endif +} + +static __attribute__((unused)) +pid_t sys_wait4 (pid_t pid,int *status,int options,struct rusage *rusage) +{ +return my_syscall4 (__NR_wait4, pid, status, options, rusage); +} + +static __attribute__((unused)) +pid_t sys_waitpid (pid_t pid,int *status,int options) +{ +return sys_wait4 (pid, status, options,0 ); +} + +static __attribute__((unused)) +pid_t sys_wait (int *status) +{ +return sys_waitpid (-1 , status,0 ); +} + +static __attribute__((unused)) +ssize_t sys_write (int fd,const void *buf,size_t count) +{ +return my_syscall3 (__NR_write, fd, buf, count); +} + + +/* Below are the libc-compatible syscalls which return x or -1 and set errno. +* They rely on the functions above. Similarly they're marked static so that it +* is possible to assign pointers to them if needed. +*/ + +static __attribute__((unused)) +int brk (void *addr) +{ +void *ret =sys_brk (addr); + +if (!ret) { +SET_ERRNO (ENOMEM ); +return -1 ; + } +return 0 ; +} + +static __attribute__((noreturn,unused)) +void exit (int status) +{ +sys_exit (status); +} + +static __attribute__((unused)) +int chdir (const char *path) +{ +int ret =sys_chdir (path); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int chmod (const char *path,mode_t mode) +{ +int ret =sys_chmod (path, mode); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int chown (const char *path,uid_t owner,gid_t group) +{ +int ret =sys_chown (path, owner, group); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int chroot (const char *path) +{ +int ret =sys_chroot (path); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int close (int fd) +{ +int ret =sys_close (fd); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int dup2 (int old,int new) +{ +int ret =sys_dup2 (old, new); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int execve (const char *filename,char *const argv[],char *const envp[]) +{ +int ret =sys_execve (filename, argv, envp); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +pid_t fork (void ) +{ +pid_t ret =sys_fork (); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int fsync (int fd) +{ +int ret =sys_fsync (fd); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int getdents64 (int fd,struct linux_dirent64 *dirp,int count) +{ +int ret =sys_getdents64 (fd, dirp, count); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +pid_t getpgrp (void ) +{ +pid_t ret =sys_getpgrp (); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +pid_t getpid (void ) +{ +pid_t ret =sys_getpid (); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int gettimeofday (struct timeval *tv,struct timezone *tz) +{ +int ret =sys_gettimeofday (tv, tz); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int ioctl (int fd,unsigned long req,void *value) +{ +int ret =sys_ioctl (fd, req, value); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int kill (pid_t pid,int signal) +{ +int ret =sys_kill (pid, signal); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int link (const char *old,const char *new) +{ +int ret =sys_link (old, new); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +off_t lseek (int fd,off_t offset,int whence) +{ +off_t ret =sys_lseek (fd, offset, whence); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int mkdir (const char *path,mode_t mode) +{ +int ret =sys_mkdir (path, mode); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int mknod (const char *path,mode_t mode,dev_t dev) +{ +int ret =sys_mknod (path, mode, dev); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int mount (const char *src,const char *tgt, +const char *fst,unsigned long flags, +const void *data) +{ +int ret =sys_mount (src, tgt, fst, flags, data); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int open (const char *path,int flags,mode_t mode) +{ +int ret =sys_open (path, flags, mode); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int pivot_root (const char *new,const char *old) +{ +int ret =sys_pivot_root (new, old); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int poll (struct pollfd *fds,int nfds,int timeout) +{ +int ret =sys_poll (fds, nfds, timeout); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +ssize_t read (int fd,void *buf,size_t count) +{ +ssize_t ret =sys_read (fd, buf, count); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int reboot (int cmd) +{ +int ret =sys_reboot (LINUX_REBOOT_MAGIC1 ,LINUX_REBOOT_MAGIC2 , cmd,0 ); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +void *sbrk (intptr_t inc) +{ +void *ret; + +/* first call to find current end */ +if ((ret =sys_brk (0 )) && (sys_brk (ret + inc) == ret + inc)) +return ret + inc; + +SET_ERRNO (ENOMEM ); +return (void *)-1 ; +} + +static __attribute__((unused)) +int sched_yield (void ) +{ +int ret =sys_sched_yield (); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int select (int nfds,fd_set *rfds,fd_set *wfds,fd_set *efds,struct timeval *timeout) +{ +int ret =sys_select (nfds, rfds, wfds, efds, timeout); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int setpgid (pid_t pid,pid_t pgid) +{ +int ret =sys_setpgid (pid, pgid); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +pid_t setsid (void ) +{ +pid_t ret =sys_setsid (); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +unsigned int sleep (unsigned int seconds) +{ +struct timeval my_timeval = { seconds,0 }; + +if (sys_select (0 ,0 ,0 ,0 , &my_timeval) <0 ) +return my_timeval.tv_sec + !!my_timeval.tv_usec; +else +return 0 ; +} + +static __attribute__((unused)) +int stat (const char *path,struct stat *buf) +{ +int ret =sys_stat (path, buf); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int symlink (const char *old,const char *new) +{ +int ret =sys_symlink (old, new); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int tcsetpgrp (int fd,pid_t pid) +{ +return ioctl (fd,TIOCSPGRP , &pid); +} + +static __attribute__((unused)) +mode_t umask (mode_t mode) +{ +return sys_umask (mode); +} + +static __attribute__((unused)) +int umount2 (const char *path,int flags) +{ +int ret =sys_umount2 (path, flags); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +int unlink (const char *path) +{ +int ret =sys_unlink (path); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +pid_t wait4 (pid_t pid,int *status,int options,struct rusage *rusage) +{ +pid_t ret =sys_wait4 (pid, status, options, rusage); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +pid_t waitpid (pid_t pid,int *status,int options) +{ +pid_t ret =sys_waitpid (pid, status, options); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +pid_t wait (int *status) +{ +pid_t ret =sys_wait (status); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +static __attribute__((unused)) +ssize_t write (int fd,const void *buf,size_t count) +{ +ssize_t ret =sys_write (fd, buf, count); + +if (ret <0 ) { +SET_ERRNO (-ret); + ret =-1 ; + } +return ret; +} + +/* some size-optimized reimplementations of a few common str* and mem* +* functions. They're marked static, except memcpy() and raise() which are used +* by libgcc on ARM, so they are marked weak instead in order not to cause an +* error when building a program made of multiple files (not recommended). +*/ + +static __attribute__((unused)) +void *memmove (void *dst,const void *src,size_t len) +{ +ssize_t pos = (dst <= src) ?-1 : (long )len; +void *ret = dst; + +while (len--) { + pos += (dst <= src) ?1 :-1 ; + ((char *)dst)[pos] = ((char *)src)[pos]; + } +return ret; +} + +static __attribute__((unused)) +void *memset (void *dst,int b,size_t len) +{ +char *p = dst; + +while (len--) + *(p++) = b; +return dst; +} + +static __attribute__((unused)) +int memcmp (const void *s1,const void *s2,size_t n) +{ +size_t ofs =0 ; +char c1 =0 ; + +while (ofs < n && !(c1 = ((char *)s1)[ofs] - ((char *)s2)[ofs])) { + ofs++; + } +return c1; +} + +static __attribute__((unused)) +char *strcpy (char *dst,const char *src) +{ +char *ret = dst; + +while ((*dst++ = *src++)); +return ret; +} + +static __attribute__((unused)) +char *strchr (const char *s,int c) +{ +while (*s) { +if (*s == (char )c) +return (char *)s; + s++; + } +return NULL ; +} + +static __attribute__((unused)) +char *strrchr (const char *s,int c) +{ +const char *ret =NULL ; + +while (*s) { +if (*s == (char )c) + ret = s; + s++; + } +return (char *)ret; +} + +static __attribute__((unused)) +size_t nolibc_strlen (const char *str) +{ +size_t len; + +for (len =0 ; str[len]; len++); +return len; +} + +#define strlen (str) ({ \ + __builtin_constant_p((str)) ? \ + __builtin_strlen((str)) : \ + nolibc_strlen((str)); \ +}) + +static __attribute__((unused)) +int isdigit (int c) +{ +return (unsigned int )(c -'0' ) <=9 ; +} + +static __attribute__((unused)) +long atol (const char *s) +{ +unsigned long ret =0 ; +unsigned long d; +int neg =0 ; + +if (*s =='-' ) { + neg =1 ; + s++; + } + +while (1 ) { + d = (*s++) -'0' ; +if (d >9 ) +break ; + ret *=10 ; + ret += d; + } + +return neg ? -ret : ret; +} + +static __attribute__((unused)) +int atoi (const char *s) +{ +return atol (s); +} + +static __attribute__((unused)) +const char *ltoa (long in) +{ +/* large enough for -9223372036854775808 */ +static char buffer[21 ]; +char *pos = buffer +sizeof (buffer) -1 ; +int neg = in <0 ; +unsigned long n = neg ? -in : in; + + *pos-- ='\0' ; +do { + *pos-- ='0' + n %10 ; + n /=10 ; +if (pos < buffer) +return pos +1 ; + }while (n); + +if (neg) + *pos-- ='-' ; +return pos +1 ; +} + +__attribute__((weak,unused)) +void *memcpy (void *dst,const void *src,size_t len) +{ +return memmove (dst, src, len); +} + +/* needed by libgcc for divide by zero */ +__attribute__((weak,unused)) +int raise (int signal) +{ +return kill (getpid (), signal); +} + +/* Here come a few helper functions */ + +static __attribute__((unused)) +void FD_ZERO (fd_set *set) +{ +memset (set,0 ,sizeof (*set)); +} + +static __attribute__((unused)) +void FD_SET (int fd,fd_set *set) +{ +if (fd <0 || fd >=FD_SETSIZE ) +return ; + set->fd32[fd /32 ] |=1 << (fd &31 ); +} + +/* WARNING, it only deals with the 4096 first majors and 256 first minors */ +static __attribute__((unused)) +dev_t makedev (unsigned int major,unsigned int minor) +{ +return ((major &0xfff ) <<8 ) | (minor &0xff ); +}
Signature · 1 line
2.17.1
PATCH 8/8 rcutorture: Make use of nolibc when available
In reply to Paul E. McKenneyFrom: Willy Tarreau <[email protected]>
This reduces the size of the init executable from ~800 kB to ~800 bytes on x86_64. This is only implemented for x86_64, i386, arm and arm64. Others not tested.
Signed-off-by Willy Tarreau <[email protected]>
Signed-off-by Paul E. McKenney <[email protected]>
--- .../selftests/rcutorture/bin/mkinitrd.sh | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-)
tools/testing/selftests/rcutorture/bin/mkinitrd.sh +17 -1
@@ -82,8 +82,10 @@ cd $D mkdir -p initrd cd initrd cat > init.c << '___EOF___' +#ifndef NOLIBC #include <unistd.h> #include <sys/time.h> +#endif volatile unsigned long delaycount;
@@ -113,7 +115,21 @@ int main(int argc, int argv[]) return 0; } ___EOF___ -${CROSS_COMPILE}gcc -s -static -Os -o init init.c + +# build using nolibc on supported archs (smaller executable) and fall +# back to regular glibc on other ones. +if echo -e "#if __x86_64__||__i386__||__i486__||__i586__||__i686__" \ + "||__ARM_EABI__||__aarch64__\nyes\n#endif" \ + | ${CROSS_COMPILE}gcc -E -nostdlib -xc - \ + | grep -q '^yes'; then + # architecture supported by nolibc + ${CROSS_COMPILE}gcc -fno-asynchronous-unwind-tables -fno-ident \ + -nostdlib -include ../bin/nolibc.h -lgcc -s -static -Os \ + -o init init.c +else + ${CROSS_COMPILE}gcc -s -static -Os -o init init.c +fi + rm init.c echo "Done creating a statically linked C-language initrd"
Signature · 1 line
2.17.1