1fddc8f81SThomas Weißschuh /* SPDX-License-Identifier: GPL-2.0 */ 2362aecb2SWilly Tarreau 31da02f51SWilly Tarreau #define _GNU_SOURCE 45f2de00eSZhangjin Wu #define _LARGEFILE64_SOURCE 51da02f51SWilly Tarreau 6362aecb2SWilly Tarreau /* libc-specific include files 71da02f51SWilly Tarreau * The program may be built in 3 ways: 8362aecb2SWilly Tarreau * $(CC) -nostdlib -include /path/to/nolibc.h => NOLIBC already defined 91da02f51SWilly Tarreau * $(CC) -nostdlib -I/path/to/nolibc/sysroot => _NOLIBC_* guards are present 101da02f51SWilly Tarreau * $(CC) with default libc => NOLIBC* never defined 11362aecb2SWilly Tarreau */ 12362aecb2SWilly Tarreau #ifndef NOLIBC 13362aecb2SWilly Tarreau #include <stdio.h> 14362aecb2SWilly Tarreau #include <stdlib.h> 15362aecb2SWilly Tarreau #include <string.h> 161da02f51SWilly Tarreau #ifndef _NOLIBC_STDIO_H 171da02f51SWilly Tarreau /* standard libcs need more includes */ 181da02f51SWilly Tarreau #include <sys/io.h> 191da02f51SWilly Tarreau #include <sys/ioctl.h> 2069f2cd9fSThomas Weißschuh #include <sys/mman.h> 211da02f51SWilly Tarreau #include <sys/mount.h> 22208aa9d9SThomas Weißschuh #include <sys/prctl.h> 231da02f51SWilly Tarreau #include <sys/reboot.h> 241da02f51SWilly Tarreau #include <sys/stat.h> 251da02f51SWilly Tarreau #include <sys/syscall.h> 261da02f51SWilly Tarreau #include <sys/sysmacros.h> 271da02f51SWilly Tarreau #include <sys/time.h> 281da02f51SWilly Tarreau #include <sys/wait.h> 291da02f51SWilly Tarreau #include <dirent.h> 301da02f51SWilly Tarreau #include <errno.h> 311da02f51SWilly Tarreau #include <fcntl.h> 321da02f51SWilly Tarreau #include <poll.h> 331da02f51SWilly Tarreau #include <sched.h> 341da02f51SWilly Tarreau #include <signal.h> 351da02f51SWilly Tarreau #include <stdarg.h> 362df07fc5SWilly Tarreau #include <stddef.h> 372df07fc5SWilly Tarreau #include <stdint.h> 381da02f51SWilly Tarreau #include <unistd.h> 39bd27fef3SZhangjin Wu #include <limits.h> 401da02f51SWilly Tarreau #endif 41362aecb2SWilly Tarreau #endif 42362aecb2SWilly Tarreau 43989abf1cSZhangjin Wu /* for the type of int_fast16_t and int_fast32_t, musl differs from glibc and nolibc */ 44989abf1cSZhangjin Wu #define SINT_MAX_OF_TYPE(type) (((type)1 << (sizeof(type) * 8 - 2)) - (type)1 + ((type)1 << (sizeof(type) * 8 - 2))) 45989abf1cSZhangjin Wu #define SINT_MIN_OF_TYPE(type) (-SINT_MAX_OF_TYPE(type) - 1) 46989abf1cSZhangjin Wu 4767d108e2SThomas Weißschuh /* will be used to test initialization of environ */ 4867d108e2SThomas Weißschuh static char **test_envp; 49362aecb2SWilly Tarreau 50938b5b98SZhangjin Wu /* will be used by some test cases as readable file, please don't write it */ 51938b5b98SZhangjin Wu static const char *argv0; 52938b5b98SZhangjin Wu 5323da7bc9SWilly Tarreau /* definition of a series of tests */ 5423da7bc9SWilly Tarreau struct test { 55fddc8f81SThomas Weißschuh const char *name; /* test name */ 56fddc8f81SThomas Weißschuh int (*func)(int min, int max); /* handler */ 5723da7bc9SWilly Tarreau }; 5823da7bc9SWilly Tarreau 591da02f51SWilly Tarreau #ifndef _NOLIBC_STDLIB_H 601da02f51SWilly Tarreau char *itoa(int i) 611da02f51SWilly Tarreau { 621da02f51SWilly Tarreau static char buf[12]; 631da02f51SWilly Tarreau int ret; 641da02f51SWilly Tarreau 651da02f51SWilly Tarreau ret = snprintf(buf, sizeof(buf), "%d", i); 661da02f51SWilly Tarreau return (ret >= 0 && ret < sizeof(buf)) ? buf : "#err"; 671da02f51SWilly Tarreau } 681da02f51SWilly Tarreau #endif 691da02f51SWilly Tarreau 70362aecb2SWilly Tarreau #define CASE_ERR(err) \ 71362aecb2SWilly Tarreau case err: return #err 72362aecb2SWilly Tarreau 73362aecb2SWilly Tarreau /* returns the error name (e.g. "ENOENT") for common errors, "SUCCESS" for 0, 74362aecb2SWilly Tarreau * or the decimal value for less common ones. 75362aecb2SWilly Tarreau */ 76362aecb2SWilly Tarreau const char *errorname(int err) 77362aecb2SWilly Tarreau { 78362aecb2SWilly Tarreau switch (err) { 79362aecb2SWilly Tarreau case 0: return "SUCCESS"; 80362aecb2SWilly Tarreau CASE_ERR(EPERM); 81362aecb2SWilly Tarreau CASE_ERR(ENOENT); 82362aecb2SWilly Tarreau CASE_ERR(ESRCH); 83362aecb2SWilly Tarreau CASE_ERR(EINTR); 84362aecb2SWilly Tarreau CASE_ERR(EIO); 85362aecb2SWilly Tarreau CASE_ERR(ENXIO); 86362aecb2SWilly Tarreau CASE_ERR(E2BIG); 87362aecb2SWilly Tarreau CASE_ERR(ENOEXEC); 88362aecb2SWilly Tarreau CASE_ERR(EBADF); 89362aecb2SWilly Tarreau CASE_ERR(ECHILD); 90362aecb2SWilly Tarreau CASE_ERR(EAGAIN); 91362aecb2SWilly Tarreau CASE_ERR(ENOMEM); 92362aecb2SWilly Tarreau CASE_ERR(EACCES); 93362aecb2SWilly Tarreau CASE_ERR(EFAULT); 94362aecb2SWilly Tarreau CASE_ERR(ENOTBLK); 95362aecb2SWilly Tarreau CASE_ERR(EBUSY); 96362aecb2SWilly Tarreau CASE_ERR(EEXIST); 97362aecb2SWilly Tarreau CASE_ERR(EXDEV); 98362aecb2SWilly Tarreau CASE_ERR(ENODEV); 99362aecb2SWilly Tarreau CASE_ERR(ENOTDIR); 100362aecb2SWilly Tarreau CASE_ERR(EISDIR); 101362aecb2SWilly Tarreau CASE_ERR(EINVAL); 102362aecb2SWilly Tarreau CASE_ERR(ENFILE); 103362aecb2SWilly Tarreau CASE_ERR(EMFILE); 104362aecb2SWilly Tarreau CASE_ERR(ENOTTY); 105362aecb2SWilly Tarreau CASE_ERR(ETXTBSY); 106362aecb2SWilly Tarreau CASE_ERR(EFBIG); 107362aecb2SWilly Tarreau CASE_ERR(ENOSPC); 108362aecb2SWilly Tarreau CASE_ERR(ESPIPE); 109362aecb2SWilly Tarreau CASE_ERR(EROFS); 110362aecb2SWilly Tarreau CASE_ERR(EMLINK); 111362aecb2SWilly Tarreau CASE_ERR(EPIPE); 112362aecb2SWilly Tarreau CASE_ERR(EDOM); 113362aecb2SWilly Tarreau CASE_ERR(ERANGE); 114362aecb2SWilly Tarreau CASE_ERR(ENOSYS); 115758f970fSZhangjin Wu CASE_ERR(EOVERFLOW); 116362aecb2SWilly Tarreau default: 117362aecb2SWilly Tarreau return itoa(err); 118362aecb2SWilly Tarreau } 119362aecb2SWilly Tarreau } 120362aecb2SWilly Tarreau 121443de903SThomas Weißschuh static void putcharn(char c, size_t n) 122443de903SThomas Weißschuh { 123443de903SThomas Weißschuh char buf[64]; 124443de903SThomas Weißschuh 125443de903SThomas Weißschuh memset(buf, c, n); 126443de903SThomas Weißschuh buf[n] = '\0'; 127443de903SThomas Weißschuh fputs(buf, stdout); 128443de903SThomas Weißschuh } 129443de903SThomas Weißschuh 130b184a261SThomas Weißschuh enum RESULT { 131b184a261SThomas Weißschuh OK, 132b184a261SThomas Weißschuh FAIL, 133b184a261SThomas Weißschuh SKIPPED, 134b184a261SThomas Weißschuh }; 135b184a261SThomas Weißschuh 136b184a261SThomas Weißschuh static void result(int llen, enum RESULT r) 137362aecb2SWilly Tarreau { 138b184a261SThomas Weißschuh const char *msg; 139362aecb2SWilly Tarreau 140b184a261SThomas Weißschuh if (r == OK) 141b184a261SThomas Weißschuh msg = " [OK]"; 142b184a261SThomas Weißschuh else if (r == SKIPPED) 143b184a261SThomas Weißschuh msg = "[SKIPPED]"; 144b184a261SThomas Weißschuh else 145b184a261SThomas Weißschuh msg = "[FAIL]"; 146362aecb2SWilly Tarreau 147b184a261SThomas Weißschuh putcharn(' ', 64 - llen); 148b184a261SThomas Weißschuh puts(msg); 149362aecb2SWilly Tarreau } 150362aecb2SWilly Tarreau 151362aecb2SWilly Tarreau /* The tests below are intended to be used by the macroes, which evaluate 152362aecb2SWilly Tarreau * expression <expr>, print the status to stdout, and update the "ret" 153362aecb2SWilly Tarreau * variable to count failures. The functions themselves return the number 154362aecb2SWilly Tarreau * of failures, thus either 0 or 1. 155362aecb2SWilly Tarreau */ 156362aecb2SWilly Tarreau 157362aecb2SWilly Tarreau #define EXPECT_ZR(cond, expr) \ 158b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_zr(expr, llen); } while (0) 159362aecb2SWilly Tarreau 160362aecb2SWilly Tarreau static int expect_zr(int expr, int llen) 161362aecb2SWilly Tarreau { 162362aecb2SWilly Tarreau int ret = !(expr == 0); 163362aecb2SWilly Tarreau 164362aecb2SWilly Tarreau llen += printf(" = %d ", expr); 165b184a261SThomas Weißschuh result(llen, ret ? FAIL : OK); 166362aecb2SWilly Tarreau return ret; 167362aecb2SWilly Tarreau } 168362aecb2SWilly Tarreau 169362aecb2SWilly Tarreau 170362aecb2SWilly Tarreau #define EXPECT_NZ(cond, expr, val) \ 171b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_nz(expr, llen; } while (0) 172362aecb2SWilly Tarreau 173362aecb2SWilly Tarreau static int expect_nz(int expr, int llen) 174362aecb2SWilly Tarreau { 175362aecb2SWilly Tarreau int ret = !(expr != 0); 176362aecb2SWilly Tarreau 177362aecb2SWilly Tarreau llen += printf(" = %d ", expr); 178b184a261SThomas Weißschuh result(llen, ret ? FAIL : OK); 179362aecb2SWilly Tarreau return ret; 180362aecb2SWilly Tarreau } 181362aecb2SWilly Tarreau 182362aecb2SWilly Tarreau 183362aecb2SWilly Tarreau #define EXPECT_EQ(cond, expr, val) \ 184b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_eq(expr, llen, val); } while (0) 185362aecb2SWilly Tarreau 186a0994fb9SVincent Dagonneau static int expect_eq(uint64_t expr, int llen, uint64_t val) 187362aecb2SWilly Tarreau { 188362aecb2SWilly Tarreau int ret = !(expr == val); 189362aecb2SWilly Tarreau 1900858aec4SZhangjin Wu llen += printf(" = %lld ", (long long)expr); 191b184a261SThomas Weißschuh result(llen, ret ? FAIL : OK); 192362aecb2SWilly Tarreau return ret; 193362aecb2SWilly Tarreau } 194362aecb2SWilly Tarreau 195362aecb2SWilly Tarreau 196362aecb2SWilly Tarreau #define EXPECT_NE(cond, expr, val) \ 197b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ne(expr, llen, val); } while (0) 198362aecb2SWilly Tarreau 199362aecb2SWilly Tarreau static int expect_ne(int expr, int llen, int val) 200362aecb2SWilly Tarreau { 201362aecb2SWilly Tarreau int ret = !(expr != val); 202362aecb2SWilly Tarreau 203362aecb2SWilly Tarreau llen += printf(" = %d ", expr); 204b184a261SThomas Weißschuh result(llen, ret ? FAIL : OK); 205362aecb2SWilly Tarreau return ret; 206362aecb2SWilly Tarreau } 207362aecb2SWilly Tarreau 208362aecb2SWilly Tarreau 209362aecb2SWilly Tarreau #define EXPECT_GE(cond, expr, val) \ 210b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ge(expr, llen, val); } while (0) 211362aecb2SWilly Tarreau 212362aecb2SWilly Tarreau static int expect_ge(int expr, int llen, int val) 213362aecb2SWilly Tarreau { 214362aecb2SWilly Tarreau int ret = !(expr >= val); 215362aecb2SWilly Tarreau 216362aecb2SWilly Tarreau llen += printf(" = %d ", expr); 217b184a261SThomas Weißschuh result(llen, ret ? FAIL : OK); 218362aecb2SWilly Tarreau return ret; 219362aecb2SWilly Tarreau } 220362aecb2SWilly Tarreau 221362aecb2SWilly Tarreau 222362aecb2SWilly Tarreau #define EXPECT_GT(cond, expr, val) \ 223b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_gt(expr, llen, val); } while (0) 224362aecb2SWilly Tarreau 225362aecb2SWilly Tarreau static int expect_gt(int expr, int llen, int val) 226362aecb2SWilly Tarreau { 227362aecb2SWilly Tarreau int ret = !(expr > val); 228362aecb2SWilly Tarreau 229362aecb2SWilly Tarreau llen += printf(" = %d ", expr); 230b184a261SThomas Weißschuh result(llen, ret ? FAIL : OK); 231362aecb2SWilly Tarreau return ret; 232362aecb2SWilly Tarreau } 233362aecb2SWilly Tarreau 234362aecb2SWilly Tarreau 235362aecb2SWilly Tarreau #define EXPECT_LE(cond, expr, val) \ 236b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_le(expr, llen, val); } while (0) 237362aecb2SWilly Tarreau 238362aecb2SWilly Tarreau static int expect_le(int expr, int llen, int val) 239362aecb2SWilly Tarreau { 240362aecb2SWilly Tarreau int ret = !(expr <= val); 241362aecb2SWilly Tarreau 242362aecb2SWilly Tarreau llen += printf(" = %d ", expr); 243b184a261SThomas Weißschuh result(llen, ret ? FAIL : OK); 244362aecb2SWilly Tarreau return ret; 245362aecb2SWilly Tarreau } 246362aecb2SWilly Tarreau 247362aecb2SWilly Tarreau 248362aecb2SWilly Tarreau #define EXPECT_LT(cond, expr, val) \ 249b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_lt(expr, llen, val); } while (0) 250362aecb2SWilly Tarreau 251362aecb2SWilly Tarreau static int expect_lt(int expr, int llen, int val) 252362aecb2SWilly Tarreau { 253362aecb2SWilly Tarreau int ret = !(expr < val); 254362aecb2SWilly Tarreau 255362aecb2SWilly Tarreau llen += printf(" = %d ", expr); 256b184a261SThomas Weißschuh result(llen, ret ? FAIL : OK); 257362aecb2SWilly Tarreau return ret; 258362aecb2SWilly Tarreau } 259362aecb2SWilly Tarreau 260362aecb2SWilly Tarreau 261362aecb2SWilly Tarreau #define EXPECT_SYSZR(cond, expr) \ 262b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_syszr(expr, llen); } while (0) 263362aecb2SWilly Tarreau 264362aecb2SWilly Tarreau static int expect_syszr(int expr, int llen) 265362aecb2SWilly Tarreau { 266362aecb2SWilly Tarreau int ret = 0; 267362aecb2SWilly Tarreau 268362aecb2SWilly Tarreau if (expr) { 269362aecb2SWilly Tarreau ret = 1; 270362aecb2SWilly Tarreau llen += printf(" = %d %s ", expr, errorname(errno)); 271b184a261SThomas Weißschuh result(llen, FAIL); 272362aecb2SWilly Tarreau } else { 273362aecb2SWilly Tarreau llen += printf(" = %d ", expr); 274b184a261SThomas Weißschuh result(llen, OK); 275362aecb2SWilly Tarreau } 276362aecb2SWilly Tarreau return ret; 277362aecb2SWilly Tarreau } 278362aecb2SWilly Tarreau 279362aecb2SWilly Tarreau 280362aecb2SWilly Tarreau #define EXPECT_SYSEQ(cond, expr, val) \ 281b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_syseq(expr, llen, val); } while (0) 282362aecb2SWilly Tarreau 283362aecb2SWilly Tarreau static int expect_syseq(int expr, int llen, int val) 284362aecb2SWilly Tarreau { 285362aecb2SWilly Tarreau int ret = 0; 286362aecb2SWilly Tarreau 287362aecb2SWilly Tarreau if (expr != val) { 288362aecb2SWilly Tarreau ret = 1; 289362aecb2SWilly Tarreau llen += printf(" = %d %s ", expr, errorname(errno)); 290b184a261SThomas Weißschuh result(llen, FAIL); 291362aecb2SWilly Tarreau } else { 292362aecb2SWilly Tarreau llen += printf(" = %d ", expr); 293b184a261SThomas Weißschuh result(llen, OK); 294362aecb2SWilly Tarreau } 295362aecb2SWilly Tarreau return ret; 296362aecb2SWilly Tarreau } 297362aecb2SWilly Tarreau 298362aecb2SWilly Tarreau 299362aecb2SWilly Tarreau #define EXPECT_SYSNE(cond, expr, val) \ 300b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_sysne(expr, llen, val); } while (0) 301362aecb2SWilly Tarreau 302362aecb2SWilly Tarreau static int expect_sysne(int expr, int llen, int val) 303362aecb2SWilly Tarreau { 304362aecb2SWilly Tarreau int ret = 0; 305362aecb2SWilly Tarreau 306362aecb2SWilly Tarreau if (expr == val) { 307362aecb2SWilly Tarreau ret = 1; 308362aecb2SWilly Tarreau llen += printf(" = %d %s ", expr, errorname(errno)); 309b184a261SThomas Weißschuh result(llen, FAIL); 310362aecb2SWilly Tarreau } else { 311362aecb2SWilly Tarreau llen += printf(" = %d ", expr); 312b184a261SThomas Weißschuh result(llen, OK); 313362aecb2SWilly Tarreau } 314362aecb2SWilly Tarreau return ret; 315362aecb2SWilly Tarreau } 316362aecb2SWilly Tarreau 317362aecb2SWilly Tarreau 31875d75a7bSZhangjin Wu #define EXPECT_SYSER2(cond, expr, expret, experr1, experr2) \ 319b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_syserr2(expr, expret, experr1, experr2, llen); } while (0) 320362aecb2SWilly Tarreau 32175d75a7bSZhangjin Wu #define EXPECT_SYSER(cond, expr, expret, experr) \ 32275d75a7bSZhangjin Wu EXPECT_SYSER2(cond, expr, expret, experr, 0) 32375d75a7bSZhangjin Wu 32475d75a7bSZhangjin Wu static int expect_syserr2(int expr, int expret, int experr1, int experr2, int llen) 325362aecb2SWilly Tarreau { 326362aecb2SWilly Tarreau int ret = 0; 327362aecb2SWilly Tarreau int _errno = errno; 328362aecb2SWilly Tarreau 329362aecb2SWilly Tarreau llen += printf(" = %d %s ", expr, errorname(_errno)); 33075d75a7bSZhangjin Wu if (expr != expret || (_errno != experr1 && _errno != experr2)) { 331362aecb2SWilly Tarreau ret = 1; 33275d75a7bSZhangjin Wu if (experr2 == 0) 33375d75a7bSZhangjin Wu llen += printf(" != (%d %s) ", expret, errorname(experr1)); 33475d75a7bSZhangjin Wu else 33575d75a7bSZhangjin Wu llen += printf(" != (%d %s %s) ", expret, errorname(experr1), errorname(experr2)); 336b184a261SThomas Weißschuh result(llen, FAIL); 337362aecb2SWilly Tarreau } else { 338b184a261SThomas Weißschuh result(llen, OK); 339362aecb2SWilly Tarreau } 340362aecb2SWilly Tarreau return ret; 341362aecb2SWilly Tarreau } 342362aecb2SWilly Tarreau 343362aecb2SWilly Tarreau 344362aecb2SWilly Tarreau #define EXPECT_PTRZR(cond, expr) \ 345b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrzr(expr, llen); } while (0) 346362aecb2SWilly Tarreau 347362aecb2SWilly Tarreau static int expect_ptrzr(const void *expr, int llen) 348362aecb2SWilly Tarreau { 349362aecb2SWilly Tarreau int ret = 0; 350362aecb2SWilly Tarreau 351362aecb2SWilly Tarreau llen += printf(" = <%p> ", expr); 352362aecb2SWilly Tarreau if (expr) { 353362aecb2SWilly Tarreau ret = 1; 354b184a261SThomas Weißschuh result(llen, FAIL); 355362aecb2SWilly Tarreau } else { 356b184a261SThomas Weißschuh result(llen, OK); 357362aecb2SWilly Tarreau } 358362aecb2SWilly Tarreau return ret; 359362aecb2SWilly Tarreau } 360362aecb2SWilly Tarreau 361362aecb2SWilly Tarreau 362362aecb2SWilly Tarreau #define EXPECT_PTRNZ(cond, expr) \ 363b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrnz(expr, llen); } while (0) 364362aecb2SWilly Tarreau 365362aecb2SWilly Tarreau static int expect_ptrnz(const void *expr, int llen) 366362aecb2SWilly Tarreau { 367362aecb2SWilly Tarreau int ret = 0; 368362aecb2SWilly Tarreau 369362aecb2SWilly Tarreau llen += printf(" = <%p> ", expr); 370362aecb2SWilly Tarreau if (!expr) { 371362aecb2SWilly Tarreau ret = 1; 372b184a261SThomas Weißschuh result(llen, FAIL); 373362aecb2SWilly Tarreau } else { 374b184a261SThomas Weißschuh result(llen, OK); 375362aecb2SWilly Tarreau } 376362aecb2SWilly Tarreau return ret; 377362aecb2SWilly Tarreau } 378362aecb2SWilly Tarreau 37929f5540bSZhangjin Wu #define EXPECT_PTREQ(cond, expr, cmp) \ 380b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptreq(expr, llen, cmp); } while (0) 38129f5540bSZhangjin Wu 38229f5540bSZhangjin Wu static int expect_ptreq(const void *expr, int llen, const void *cmp) 38329f5540bSZhangjin Wu { 38429f5540bSZhangjin Wu int ret = 0; 38529f5540bSZhangjin Wu 38629f5540bSZhangjin Wu llen += printf(" = <%p> ", expr); 38729f5540bSZhangjin Wu if (expr != cmp) { 38829f5540bSZhangjin Wu ret = 1; 389b184a261SThomas Weißschuh result(llen, FAIL); 39029f5540bSZhangjin Wu } else { 391b184a261SThomas Weißschuh result(llen, OK); 39229f5540bSZhangjin Wu } 39329f5540bSZhangjin Wu return ret; 39429f5540bSZhangjin Wu } 39529f5540bSZhangjin Wu 39629f5540bSZhangjin Wu #define EXPECT_PTRNE(cond, expr, cmp) \ 397b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrne(expr, llen, cmp); } while (0) 39829f5540bSZhangjin Wu 39929f5540bSZhangjin Wu static int expect_ptrne(const void *expr, int llen, const void *cmp) 40029f5540bSZhangjin Wu { 40129f5540bSZhangjin Wu int ret = 0; 40229f5540bSZhangjin Wu 40329f5540bSZhangjin Wu llen += printf(" = <%p> ", expr); 40429f5540bSZhangjin Wu if (expr == cmp) { 40529f5540bSZhangjin Wu ret = 1; 406b184a261SThomas Weißschuh result(llen, FAIL); 40729f5540bSZhangjin Wu } else { 408b184a261SThomas Weißschuh result(llen, OK); 40929f5540bSZhangjin Wu } 41029f5540bSZhangjin Wu return ret; 41129f5540bSZhangjin Wu } 41229f5540bSZhangjin Wu 413*fd3a9efdSZhangjin Wu #define EXPECT_PTRGE(cond, expr, cmp) \ 414*fd3a9efdSZhangjin Wu do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrge(expr, llen, cmp); } while (0) 415*fd3a9efdSZhangjin Wu 416*fd3a9efdSZhangjin Wu static int expect_ptrge(const void *expr, int llen, const void *cmp) 417*fd3a9efdSZhangjin Wu { 418*fd3a9efdSZhangjin Wu int ret = !(expr >= cmp); 419*fd3a9efdSZhangjin Wu 420*fd3a9efdSZhangjin Wu llen += printf(" = <%p> ", expr); 421*fd3a9efdSZhangjin Wu result(llen, ret ? FAIL : OK); 422*fd3a9efdSZhangjin Wu return ret; 423*fd3a9efdSZhangjin Wu } 424*fd3a9efdSZhangjin Wu 425*fd3a9efdSZhangjin Wu #define EXPECT_PTRGT(cond, expr, cmp) \ 426*fd3a9efdSZhangjin Wu do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrgt(expr, llen, cmp); } while (0) 427*fd3a9efdSZhangjin Wu 428*fd3a9efdSZhangjin Wu static int expect_ptrgt(const void *expr, int llen, const void *cmp) 429*fd3a9efdSZhangjin Wu { 430*fd3a9efdSZhangjin Wu int ret = !(expr > cmp); 431*fd3a9efdSZhangjin Wu 432*fd3a9efdSZhangjin Wu llen += printf(" = <%p> ", expr); 433*fd3a9efdSZhangjin Wu result(llen, ret ? FAIL : OK); 434*fd3a9efdSZhangjin Wu return ret; 435*fd3a9efdSZhangjin Wu } 436*fd3a9efdSZhangjin Wu 437*fd3a9efdSZhangjin Wu 438*fd3a9efdSZhangjin Wu #define EXPECT_PTRLE(cond, expr, cmp) \ 439*fd3a9efdSZhangjin Wu do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrle(expr, llen, cmp); } while (0) 440*fd3a9efdSZhangjin Wu 441*fd3a9efdSZhangjin Wu static int expect_ptrle(const void *expr, int llen, const void *cmp) 442*fd3a9efdSZhangjin Wu { 443*fd3a9efdSZhangjin Wu int ret = !(expr <= cmp); 444*fd3a9efdSZhangjin Wu 445*fd3a9efdSZhangjin Wu llen += printf(" = <%p> ", expr); 446*fd3a9efdSZhangjin Wu result(llen, ret ? FAIL : OK); 447*fd3a9efdSZhangjin Wu return ret; 448*fd3a9efdSZhangjin Wu } 449*fd3a9efdSZhangjin Wu 450*fd3a9efdSZhangjin Wu 451*fd3a9efdSZhangjin Wu #define EXPECT_PTRLT(cond, expr, cmp) \ 452*fd3a9efdSZhangjin Wu do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrlt(expr, llen, cmp); } while (0) 453*fd3a9efdSZhangjin Wu 454*fd3a9efdSZhangjin Wu static int expect_ptrlt(const void *expr, int llen, const void *cmp) 455*fd3a9efdSZhangjin Wu { 456*fd3a9efdSZhangjin Wu int ret = !(expr < cmp); 457*fd3a9efdSZhangjin Wu 458*fd3a9efdSZhangjin Wu llen += printf(" = <%p> ", expr); 459*fd3a9efdSZhangjin Wu result(llen, ret ? FAIL : OK); 460*fd3a9efdSZhangjin Wu return ret; 461*fd3a9efdSZhangjin Wu } 462*fd3a9efdSZhangjin Wu 46329f5540bSZhangjin Wu #define EXPECT_PTRER2(cond, expr, expret, experr1, experr2) \ 464b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrerr2(expr, expret, experr1, experr2, llen); } while (0) 46529f5540bSZhangjin Wu 46629f5540bSZhangjin Wu #define EXPECT_PTRER(cond, expr, expret, experr) \ 46729f5540bSZhangjin Wu EXPECT_PTRER2(cond, expr, expret, experr, 0) 46829f5540bSZhangjin Wu 46929f5540bSZhangjin Wu static int expect_ptrerr2(const void *expr, const void *expret, int experr1, int experr2, int llen) 47029f5540bSZhangjin Wu { 47129f5540bSZhangjin Wu int ret = 0; 47229f5540bSZhangjin Wu int _errno = errno; 47329f5540bSZhangjin Wu 47429f5540bSZhangjin Wu llen += printf(" = <%p> %s ", expr, errorname(_errno)); 47529f5540bSZhangjin Wu if (expr != expret || (_errno != experr1 && _errno != experr2)) { 47629f5540bSZhangjin Wu ret = 1; 47729f5540bSZhangjin Wu if (experr2 == 0) 47829f5540bSZhangjin Wu llen += printf(" != (<%p> %s) ", expret, errorname(experr1)); 47929f5540bSZhangjin Wu else 48029f5540bSZhangjin Wu llen += printf(" != (<%p> %s %s) ", expret, errorname(experr1), errorname(experr2)); 481b184a261SThomas Weißschuh result(llen, FAIL); 48229f5540bSZhangjin Wu } else { 483b184a261SThomas Weißschuh result(llen, OK); 48429f5540bSZhangjin Wu } 48529f5540bSZhangjin Wu return ret; 48629f5540bSZhangjin Wu } 487362aecb2SWilly Tarreau 488362aecb2SWilly Tarreau #define EXPECT_STRZR(cond, expr) \ 489b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_strzr(expr, llen); } while (0) 490362aecb2SWilly Tarreau 491362aecb2SWilly Tarreau static int expect_strzr(const char *expr, int llen) 492362aecb2SWilly Tarreau { 493362aecb2SWilly Tarreau int ret = 0; 494362aecb2SWilly Tarreau 495362aecb2SWilly Tarreau llen += printf(" = <%s> ", expr); 496362aecb2SWilly Tarreau if (expr) { 497362aecb2SWilly Tarreau ret = 1; 498b184a261SThomas Weißschuh result(llen, FAIL); 499362aecb2SWilly Tarreau } else { 500b184a261SThomas Weißschuh result(llen, OK); 501362aecb2SWilly Tarreau } 502362aecb2SWilly Tarreau return ret; 503362aecb2SWilly Tarreau } 504362aecb2SWilly Tarreau 505362aecb2SWilly Tarreau 506362aecb2SWilly Tarreau #define EXPECT_STRNZ(cond, expr) \ 507b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_strnz(expr, llen); } while (0) 508362aecb2SWilly Tarreau 509362aecb2SWilly Tarreau static int expect_strnz(const char *expr, int llen) 510362aecb2SWilly Tarreau { 511362aecb2SWilly Tarreau int ret = 0; 512362aecb2SWilly Tarreau 513362aecb2SWilly Tarreau llen += printf(" = <%s> ", expr); 514362aecb2SWilly Tarreau if (!expr) { 515362aecb2SWilly Tarreau ret = 1; 516b184a261SThomas Weißschuh result(llen, FAIL); 517362aecb2SWilly Tarreau } else { 518b184a261SThomas Weißschuh result(llen, OK); 519362aecb2SWilly Tarreau } 520362aecb2SWilly Tarreau return ret; 521362aecb2SWilly Tarreau } 522362aecb2SWilly Tarreau 523362aecb2SWilly Tarreau 524362aecb2SWilly Tarreau #define EXPECT_STREQ(cond, expr, cmp) \ 525b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_streq(expr, llen, cmp); } while (0) 526362aecb2SWilly Tarreau 527362aecb2SWilly Tarreau static int expect_streq(const char *expr, int llen, const char *cmp) 528362aecb2SWilly Tarreau { 529362aecb2SWilly Tarreau int ret = 0; 530362aecb2SWilly Tarreau 531362aecb2SWilly Tarreau llen += printf(" = <%s> ", expr); 532362aecb2SWilly Tarreau if (strcmp(expr, cmp) != 0) { 533362aecb2SWilly Tarreau ret = 1; 534b184a261SThomas Weißschuh result(llen, FAIL); 535362aecb2SWilly Tarreau } else { 536b184a261SThomas Weißschuh result(llen, OK); 537362aecb2SWilly Tarreau } 538362aecb2SWilly Tarreau return ret; 539362aecb2SWilly Tarreau } 540362aecb2SWilly Tarreau 541362aecb2SWilly Tarreau 542362aecb2SWilly Tarreau #define EXPECT_STRNE(cond, expr, cmp) \ 543b184a261SThomas Weißschuh do { if (!(cond)) result(llen, SKIPPED); else ret += expect_strne(expr, llen, cmp); } while (0) 544362aecb2SWilly Tarreau 545362aecb2SWilly Tarreau static int expect_strne(const char *expr, int llen, const char *cmp) 546362aecb2SWilly Tarreau { 547362aecb2SWilly Tarreau int ret = 0; 548362aecb2SWilly Tarreau 549362aecb2SWilly Tarreau llen += printf(" = <%s> ", expr); 550362aecb2SWilly Tarreau if (strcmp(expr, cmp) == 0) { 551362aecb2SWilly Tarreau ret = 1; 552b184a261SThomas Weißschuh result(llen, FAIL); 553362aecb2SWilly Tarreau } else { 554b184a261SThomas Weißschuh result(llen, OK); 555362aecb2SWilly Tarreau } 556362aecb2SWilly Tarreau return ret; 557362aecb2SWilly Tarreau } 558362aecb2SWilly Tarreau 55923da7bc9SWilly Tarreau 560362aecb2SWilly Tarreau /* declare tests based on line numbers. There must be exactly one test per line. */ 561362aecb2SWilly Tarreau #define CASE_TEST(name) \ 562362aecb2SWilly Tarreau case __LINE__: llen += printf("%d %s", test, #name); 563362aecb2SWilly Tarreau 564362aecb2SWilly Tarreau 565b4844fa0SWilly Tarreau /* used by some syscall tests below */ 566b4844fa0SWilly Tarreau int test_getdents64(const char *dir) 567b4844fa0SWilly Tarreau { 568b4844fa0SWilly Tarreau char buffer[4096]; 569b4844fa0SWilly Tarreau int fd, ret; 570b4844fa0SWilly Tarreau int err; 571b4844fa0SWilly Tarreau 572b4844fa0SWilly Tarreau ret = fd = open(dir, O_RDONLY | O_DIRECTORY, 0); 573b4844fa0SWilly Tarreau if (ret < 0) 574b4844fa0SWilly Tarreau return ret; 575b4844fa0SWilly Tarreau 576b4844fa0SWilly Tarreau ret = getdents64(fd, (void *)buffer, sizeof(buffer)); 577b4844fa0SWilly Tarreau err = errno; 578b4844fa0SWilly Tarreau close(fd); 579b4844fa0SWilly Tarreau 580b4844fa0SWilly Tarreau errno = err; 581b4844fa0SWilly Tarreau return ret; 582b4844fa0SWilly Tarreau } 583b4844fa0SWilly Tarreau 584a290296aSAmmar Faizi static int test_getpagesize(void) 585a290296aSAmmar Faizi { 586a290296aSAmmar Faizi long x = getpagesize(); 587a290296aSAmmar Faizi int c; 588a290296aSAmmar Faizi 589a290296aSAmmar Faizi if (x < 0) 590a290296aSAmmar Faizi return x; 591a290296aSAmmar Faizi 592a290296aSAmmar Faizi #if defined(__x86_64__) || defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__) 593a290296aSAmmar Faizi /* 594a290296aSAmmar Faizi * x86 family is always 4K page. 595a290296aSAmmar Faizi */ 596a290296aSAmmar Faizi c = (x == 4096); 597a290296aSAmmar Faizi #elif defined(__aarch64__) 598a290296aSAmmar Faizi /* 599a290296aSAmmar Faizi * Linux aarch64 supports three values of page size: 4K, 16K, and 64K 600a290296aSAmmar Faizi * which are selected at kernel compilation time. 601a290296aSAmmar Faizi */ 602a290296aSAmmar Faizi c = (x == 4096 || x == (16 * 1024) || x == (64 * 1024)); 603a290296aSAmmar Faizi #else 604a290296aSAmmar Faizi /* 605a290296aSAmmar Faizi * Assuming other architectures must have at least 4K page. 606a290296aSAmmar Faizi */ 607a290296aSAmmar Faizi c = (x >= 4096); 608a290296aSAmmar Faizi #endif 609a290296aSAmmar Faizi 610a290296aSAmmar Faizi return !c; 611a290296aSAmmar Faizi } 612a290296aSAmmar Faizi 6133ad09d72SThomas Weißschuh static int test_fork(void) 6143ad09d72SThomas Weißschuh { 6153ad09d72SThomas Weißschuh int status; 616ed495f09SZhangjin Wu pid_t pid; 617ed495f09SZhangjin Wu 618ed495f09SZhangjin Wu /* flush the printf buffer to avoid child flush it */ 619ed495f09SZhangjin Wu fflush(stdout); 620ed495f09SZhangjin Wu fflush(stderr); 621ed495f09SZhangjin Wu 622ed495f09SZhangjin Wu pid = fork(); 6233ad09d72SThomas Weißschuh 6243ad09d72SThomas Weißschuh switch (pid) { 6253ad09d72SThomas Weißschuh case -1: 6263ad09d72SThomas Weißschuh return 1; 6273ad09d72SThomas Weißschuh 6283ad09d72SThomas Weißschuh case 0: 6293ad09d72SThomas Weißschuh exit(123); 6303ad09d72SThomas Weißschuh 6313ad09d72SThomas Weißschuh default: 6323ad09d72SThomas Weißschuh pid = waitpid(pid, &status, 0); 6333ad09d72SThomas Weißschuh 6343ad09d72SThomas Weißschuh return pid == -1 || !WIFEXITED(status) || WEXITSTATUS(status) != 123; 6353ad09d72SThomas Weißschuh } 6363ad09d72SThomas Weißschuh } 6373ad09d72SThomas Weißschuh 63887b9fa66SThomas Weißschuh static int test_stat_timestamps(void) 63987b9fa66SThomas Weißschuh { 64087b9fa66SThomas Weißschuh struct stat st; 64187b9fa66SThomas Weißschuh 64287b9fa66SThomas Weißschuh if (sizeof(st.st_atim.tv_sec) != sizeof(st.st_atime)) 64387b9fa66SThomas Weißschuh return 1; 64487b9fa66SThomas Weißschuh 645f576d3c0SZhangjin Wu if (stat("/proc/self/", &st) && stat(argv0, &st) && stat("/", &st)) 64687b9fa66SThomas Weißschuh return 1; 64787b9fa66SThomas Weißschuh 64887b9fa66SThomas Weißschuh if (st.st_atim.tv_sec != st.st_atime || st.st_atim.tv_nsec > 1000000000) 64987b9fa66SThomas Weißschuh return 1; 65087b9fa66SThomas Weißschuh 65187b9fa66SThomas Weißschuh if (st.st_mtim.tv_sec != st.st_mtime || st.st_mtim.tv_nsec > 1000000000) 65287b9fa66SThomas Weißschuh return 1; 65387b9fa66SThomas Weißschuh 65487b9fa66SThomas Weißschuh if (st.st_ctim.tv_sec != st.st_ctime || st.st_ctim.tv_nsec > 1000000000) 65587b9fa66SThomas Weißschuh return 1; 65687b9fa66SThomas Weißschuh 65787b9fa66SThomas Weißschuh return 0; 65887b9fa66SThomas Weißschuh } 65987b9fa66SThomas Weißschuh 660fcdbf5ddSZhangjin Wu int test_mmap_munmap(void) 661fcdbf5ddSZhangjin Wu { 662fcdbf5ddSZhangjin Wu int ret, fd, i; 663fcdbf5ddSZhangjin Wu void *mem; 664fcdbf5ddSZhangjin Wu size_t page_size, file_size, length; 665fcdbf5ddSZhangjin Wu off_t offset, pa_offset; 666fcdbf5ddSZhangjin Wu struct stat stat_buf; 667fcdbf5ddSZhangjin Wu const char * const files[] = { 668fcdbf5ddSZhangjin Wu "/dev/zero", 669fcdbf5ddSZhangjin Wu "/proc/1/exe", "/proc/self/exe", 670fcdbf5ddSZhangjin Wu argv0, 671fcdbf5ddSZhangjin Wu NULL 672fcdbf5ddSZhangjin Wu }; 673fcdbf5ddSZhangjin Wu 674fcdbf5ddSZhangjin Wu page_size = getpagesize(); 675fcdbf5ddSZhangjin Wu if (page_size < 0) 676fcdbf5ddSZhangjin Wu return -1; 677fcdbf5ddSZhangjin Wu 678fcdbf5ddSZhangjin Wu /* find a right file to mmap, existed and accessible */ 679fcdbf5ddSZhangjin Wu for (i = 0; files[i] != NULL; i++) { 680fcdbf5ddSZhangjin Wu ret = fd = open(files[i], O_RDONLY); 681fcdbf5ddSZhangjin Wu if (ret == -1) 682fcdbf5ddSZhangjin Wu continue; 683fcdbf5ddSZhangjin Wu else 684fcdbf5ddSZhangjin Wu break; 685fcdbf5ddSZhangjin Wu } 686fcdbf5ddSZhangjin Wu if (ret == -1) 687fcdbf5ddSZhangjin Wu return ret; 688fcdbf5ddSZhangjin Wu 689fcdbf5ddSZhangjin Wu ret = stat(files[i], &stat_buf); 690fcdbf5ddSZhangjin Wu if (ret == -1) 691fcdbf5ddSZhangjin Wu goto end; 692fcdbf5ddSZhangjin Wu 693fcdbf5ddSZhangjin Wu /* file size of the special /dev/zero is 0, let's assign one manually */ 694fcdbf5ddSZhangjin Wu if (i == 0) 695fcdbf5ddSZhangjin Wu file_size = 3*page_size; 696fcdbf5ddSZhangjin Wu else 697fcdbf5ddSZhangjin Wu file_size = stat_buf.st_size; 698fcdbf5ddSZhangjin Wu 699fcdbf5ddSZhangjin Wu offset = file_size - 1; 700fcdbf5ddSZhangjin Wu if (offset < 0) 701fcdbf5ddSZhangjin Wu offset = 0; 702fcdbf5ddSZhangjin Wu length = file_size - offset; 703fcdbf5ddSZhangjin Wu pa_offset = offset & ~(page_size - 1); 704fcdbf5ddSZhangjin Wu 705fcdbf5ddSZhangjin Wu mem = mmap(NULL, length + offset - pa_offset, PROT_READ, MAP_SHARED, fd, pa_offset); 706fcdbf5ddSZhangjin Wu if (mem == MAP_FAILED) { 707fcdbf5ddSZhangjin Wu ret = -1; 708fcdbf5ddSZhangjin Wu goto end; 709fcdbf5ddSZhangjin Wu } 710fcdbf5ddSZhangjin Wu 711fcdbf5ddSZhangjin Wu ret = munmap(mem, length + offset - pa_offset); 712fcdbf5ddSZhangjin Wu 713fcdbf5ddSZhangjin Wu end: 714fcdbf5ddSZhangjin Wu close(fd); 715fcdbf5ddSZhangjin Wu return ret; 716fcdbf5ddSZhangjin Wu } 717fcdbf5ddSZhangjin Wu 718fcdbf5ddSZhangjin Wu 719b4844fa0SWilly Tarreau /* Run syscall tests between IDs <min> and <max>. 720b4844fa0SWilly Tarreau * Return 0 on success, non-zero on failure. 721b4844fa0SWilly Tarreau */ 722b4844fa0SWilly Tarreau int run_syscall(int min, int max) 723b4844fa0SWilly Tarreau { 724957bfa31SZhangjin Wu struct timeval tv; 725957bfa31SZhangjin Wu struct timezone tz; 726b4844fa0SWilly Tarreau struct stat stat_buf; 7273e2d337bSWilly Tarreau int euid0; 7287172f1c6SWilly Tarreau int proc; 729b4844fa0SWilly Tarreau int test; 730b4844fa0SWilly Tarreau int tmp; 731b4844fa0SWilly Tarreau int ret = 0; 732b4844fa0SWilly Tarreau void *p1, *p2; 73379b4f68eSZhangjin Wu int has_gettid = 1; 734b4844fa0SWilly Tarreau 7357172f1c6SWilly Tarreau /* <proc> indicates whether or not /proc is mounted */ 7367172f1c6SWilly Tarreau proc = stat("/proc", &stat_buf) == 0; 7377172f1c6SWilly Tarreau 7383e2d337bSWilly Tarreau /* this will be used to skip certain tests that can't be run unprivileged */ 7393e2d337bSWilly Tarreau euid0 = geteuid() == 0; 7403e2d337bSWilly Tarreau 74179b4f68eSZhangjin Wu /* from 2.30, glibc provides gettid() */ 74279b4f68eSZhangjin Wu #if defined(__GLIBC_MINOR__) && defined(__GLIBC__) 74379b4f68eSZhangjin Wu has_gettid = __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 30); 74479b4f68eSZhangjin Wu #endif 74579b4f68eSZhangjin Wu 746b4844fa0SWilly Tarreau for (test = min; test >= 0 && test <= max; test++) { 747fddc8f81SThomas Weißschuh int llen = 0; /* line length */ 748b4844fa0SWilly Tarreau 749b4844fa0SWilly Tarreau /* avoid leaving empty lines below, this will insert holes into 750b4844fa0SWilly Tarreau * test numbers. 751b4844fa0SWilly Tarreau */ 752b4844fa0SWilly Tarreau switch (test + __LINE__ + 1) { 753b4844fa0SWilly Tarreau CASE_TEST(getpid); EXPECT_SYSNE(1, getpid(), -1); break; 754b4844fa0SWilly Tarreau CASE_TEST(getppid); EXPECT_SYSNE(1, getppid(), -1); break; 75579b4f68eSZhangjin Wu CASE_TEST(gettid); EXPECT_SYSNE(has_gettid, gettid(), -1); break; 756b4844fa0SWilly Tarreau CASE_TEST(getpgid_self); EXPECT_SYSNE(1, getpgid(0), -1); break; 757b4844fa0SWilly Tarreau CASE_TEST(getpgid_bad); EXPECT_SYSER(1, getpgid(-1), -1, ESRCH); break; 758b4844fa0SWilly Tarreau CASE_TEST(kill_0); EXPECT_SYSZR(1, kill(getpid(), 0)); break; 759b4844fa0SWilly Tarreau CASE_TEST(kill_CONT); EXPECT_SYSZR(1, kill(getpid(), 0)); break; 760b4844fa0SWilly Tarreau CASE_TEST(kill_BADPID); EXPECT_SYSER(1, kill(INT_MAX, 0), -1, ESRCH); break; 761f193ecbfSZhangjin Wu CASE_TEST(sbrk_0); EXPECT_PTRNE(1, sbrk(0), (void *)-1); break; 762b4844fa0SWilly Tarreau CASE_TEST(sbrk); if ((p1 = p2 = sbrk(4096)) != (void *)-1) p2 = sbrk(-4096); EXPECT_SYSZR(1, (p2 == (void *)-1) || p2 == p1); break; 763b4844fa0SWilly Tarreau CASE_TEST(brk); EXPECT_SYSZR(1, brk(sbrk(0))); break; 76438fc0a35SZhangjin Wu CASE_TEST(chdir_root); EXPECT_SYSZR(1, chdir("/")); chdir(getenv("PWD")); break; 765b4844fa0SWilly Tarreau CASE_TEST(chdir_dot); EXPECT_SYSZR(1, chdir(".")); break; 766b4844fa0SWilly Tarreau CASE_TEST(chdir_blah); EXPECT_SYSER(1, chdir("/blah"), -1, ENOENT); break; 767148e9718SZhangjin Wu CASE_TEST(chmod_argv0); EXPECT_SYSZR(1, chmod(argv0, 0555)); break; 7687172f1c6SWilly Tarreau CASE_TEST(chmod_net); EXPECT_SYSZR(proc, chmod("/proc/self/net", 0555)); break; 7697172f1c6SWilly Tarreau CASE_TEST(chmod_self); EXPECT_SYSER(proc, chmod("/proc/self", 0555), -1, EPERM); break; 7707172f1c6SWilly Tarreau CASE_TEST(chown_self); EXPECT_SYSER(proc, chown("/proc/self", 0, 0), -1, EPERM); break; 7713e2d337bSWilly Tarreau CASE_TEST(chroot_root); EXPECT_SYSZR(euid0, chroot("/")); break; 772b4844fa0SWilly Tarreau CASE_TEST(chroot_blah); EXPECT_SYSER(1, chroot("/proc/self/blah"), -1, ENOENT); break; 773135b622eSZhangjin Wu CASE_TEST(chroot_exe); EXPECT_SYSER(1, chroot(argv0), -1, ENOTDIR); break; 774b4844fa0SWilly Tarreau CASE_TEST(close_m1); EXPECT_SYSER(1, close(-1), -1, EBADF); break; 775b4844fa0SWilly Tarreau CASE_TEST(close_dup); EXPECT_SYSZR(1, close(dup(0))); break; 776b4844fa0SWilly Tarreau CASE_TEST(dup_0); tmp = dup(0); EXPECT_SYSNE(1, tmp, -1); close(tmp); break; 777b4844fa0SWilly Tarreau CASE_TEST(dup_m1); tmp = dup(-1); EXPECT_SYSER(1, tmp, -1, EBADF); if (tmp != -1) close(tmp); break; 778b4844fa0SWilly Tarreau CASE_TEST(dup2_0); tmp = dup2(0, 100); EXPECT_SYSNE(1, tmp, -1); close(tmp); break; 779b4844fa0SWilly Tarreau CASE_TEST(dup2_m1); tmp = dup2(-1, 100); EXPECT_SYSER(1, tmp, -1, EBADF); if (tmp != -1) close(tmp); break; 780b4844fa0SWilly Tarreau CASE_TEST(dup3_0); tmp = dup3(0, 100, 0); EXPECT_SYSNE(1, tmp, -1); close(tmp); break; 781b4844fa0SWilly Tarreau CASE_TEST(dup3_m1); tmp = dup3(-1, 100, 0); EXPECT_SYSER(1, tmp, -1, EBADF); if (tmp != -1) close(tmp); break; 782b4844fa0SWilly Tarreau CASE_TEST(execve_root); EXPECT_SYSER(1, execve("/", (char*[]){ [0] = "/", [1] = NULL }, NULL), -1, EACCES); break; 7833ad09d72SThomas Weißschuh CASE_TEST(fork); EXPECT_SYSZR(1, test_fork()); break; 784b4844fa0SWilly Tarreau CASE_TEST(getdents64_root); EXPECT_SYSNE(1, test_getdents64("/"), -1); break; 785b4844fa0SWilly Tarreau CASE_TEST(getdents64_null); EXPECT_SYSER(1, test_getdents64("/dev/null"), -1, ENOTDIR); break; 786957bfa31SZhangjin Wu CASE_TEST(gettimeofday_tv); EXPECT_SYSZR(1, gettimeofday(&tv, NULL)); break; 787957bfa31SZhangjin Wu CASE_TEST(gettimeofday_tv_tz);EXPECT_SYSZR(1, gettimeofday(&tv, &tz)); break; 788a290296aSAmmar Faizi CASE_TEST(getpagesize); EXPECT_SYSZR(1, test_getpagesize()); break; 789b4844fa0SWilly Tarreau CASE_TEST(ioctl_tiocinq); EXPECT_SYSZR(1, ioctl(0, TIOCINQ, &tmp)); break; 790b4844fa0SWilly Tarreau CASE_TEST(ioctl_tiocinq); EXPECT_SYSZR(1, ioctl(0, TIOCINQ, &tmp)); break; 791b4844fa0SWilly Tarreau CASE_TEST(link_root1); EXPECT_SYSER(1, link("/", "/"), -1, EEXIST); break; 792b4844fa0SWilly Tarreau CASE_TEST(link_blah); EXPECT_SYSER(1, link("/proc/self/blah", "/blah"), -1, ENOENT); break; 7933e2d337bSWilly Tarreau CASE_TEST(link_dir); EXPECT_SYSER(euid0, link("/", "/blah"), -1, EPERM); break; 794f7a419e3SZhangjin Wu CASE_TEST(link_cross); EXPECT_SYSER(proc, link("/proc/self/cmdline", "/blah"), -1, EXDEV); break; 795b4844fa0SWilly Tarreau CASE_TEST(lseek_m1); EXPECT_SYSER(1, lseek(-1, 0, SEEK_SET), -1, EBADF); break; 796b4844fa0SWilly Tarreau CASE_TEST(lseek_0); EXPECT_SYSER(1, lseek(0, 0, SEEK_SET), -1, ESPIPE); break; 797b4844fa0SWilly Tarreau CASE_TEST(mkdir_root); EXPECT_SYSER(1, mkdir("/", 0755), -1, EEXIST); break; 798d4a3b2b9SZhangjin Wu CASE_TEST(mmap_bad); EXPECT_PTRER(1, mmap(NULL, 0, PROT_READ, MAP_PRIVATE, 0, 0), MAP_FAILED, EINVAL); break; 799ba3d0892SZhangjin Wu CASE_TEST(munmap_bad); EXPECT_SYSER(1, munmap((void *)1, 0), -1, EINVAL); break; 800fcdbf5ddSZhangjin Wu CASE_TEST(mmap_munmap_good); EXPECT_SYSZR(1, test_mmap_munmap()); break; 801b4844fa0SWilly Tarreau CASE_TEST(open_tty); EXPECT_SYSNE(1, tmp = open("/dev/null", 0), -1); if (tmp != -1) close(tmp); break; 802b4844fa0SWilly Tarreau CASE_TEST(open_blah); EXPECT_SYSER(1, tmp = open("/proc/self/blah", 0), -1, ENOENT); if (tmp != -1) close(tmp); break; 803b4844fa0SWilly Tarreau CASE_TEST(poll_null); EXPECT_SYSZR(1, poll(NULL, 0, 0)); break; 804b4844fa0SWilly Tarreau CASE_TEST(poll_stdout); EXPECT_SYSNE(1, ({ struct pollfd fds = { 1, POLLOUT, 0}; poll(&fds, 1, 0); }), -1); break; 805b4844fa0SWilly Tarreau CASE_TEST(poll_fault); EXPECT_SYSER(1, poll((void *)1, 1, 0), -1, EFAULT); break; 806208aa9d9SThomas Weißschuh CASE_TEST(prctl); EXPECT_SYSER(1, prctl(PR_SET_NAME, (unsigned long)NULL, 0, 0, 0), -1, EFAULT); break; 807b4844fa0SWilly Tarreau CASE_TEST(read_badf); EXPECT_SYSER(1, read(-1, &tmp, 1), -1, EBADF); break; 8084e14e844SZhangjin Wu CASE_TEST(rmdir_blah); EXPECT_SYSER(1, rmdir("/blah"), -1, ENOENT); break; 809b4844fa0SWilly Tarreau CASE_TEST(sched_yield); EXPECT_SYSZR(1, sched_yield()); break; 810b4844fa0SWilly Tarreau CASE_TEST(select_null); EXPECT_SYSZR(1, ({ struct timeval tv = { 0 }; select(0, NULL, NULL, NULL, &tv); })); break; 811b4844fa0SWilly Tarreau CASE_TEST(select_stdout); EXPECT_SYSNE(1, ({ fd_set fds; FD_ZERO(&fds); FD_SET(1, &fds); select(2, NULL, &fds, NULL, NULL); }), -1); break; 812b4844fa0SWilly Tarreau CASE_TEST(select_fault); EXPECT_SYSER(1, select(1, (void *)1, NULL, NULL, 0), -1, EFAULT); break; 813b4844fa0SWilly Tarreau CASE_TEST(stat_blah); EXPECT_SYSER(1, stat("/proc/self/blah", &stat_buf), -1, ENOENT); break; 81446cf630cSZhangjin Wu CASE_TEST(stat_fault); EXPECT_SYSER(1, stat((void *)1, &stat_buf), -1, EFAULT); break; 81587b9fa66SThomas Weißschuh CASE_TEST(stat_timestamps); EXPECT_SYSZR(1, test_stat_timestamps()); break; 816b4844fa0SWilly Tarreau CASE_TEST(symlink_root); EXPECT_SYSER(1, symlink("/", "/"), -1, EEXIST); break; 817b4844fa0SWilly Tarreau CASE_TEST(unlink_root); EXPECT_SYSER(1, unlink("/"), -1, EISDIR); break; 818b4844fa0SWilly Tarreau CASE_TEST(unlink_blah); EXPECT_SYSER(1, unlink("/proc/self/blah"), -1, ENOENT); break; 819b4844fa0SWilly Tarreau CASE_TEST(wait_child); EXPECT_SYSER(1, wait(&tmp), -1, ECHILD); break; 820b4844fa0SWilly Tarreau CASE_TEST(waitpid_min); EXPECT_SYSER(1, waitpid(INT_MIN, &tmp, WNOHANG), -1, ESRCH); break; 821b4844fa0SWilly Tarreau CASE_TEST(waitpid_child); EXPECT_SYSER(1, waitpid(getpid(), &tmp, WNOHANG), -1, ECHILD); break; 822b4844fa0SWilly Tarreau CASE_TEST(write_badf); EXPECT_SYSER(1, write(-1, &tmp, 1), -1, EBADF); break; 823b4844fa0SWilly Tarreau CASE_TEST(write_zero); EXPECT_SYSZR(1, write(1, &tmp, 0)); break; 82453fcfafaSThomas Weißschuh CASE_TEST(syscall_noargs); EXPECT_SYSEQ(1, syscall(__NR_getpid), getpid()); break; 825ec8e1b73SZhangjin Wu CASE_TEST(syscall_args); EXPECT_SYSER(1, syscall(__NR_statx, 0, NULL, 0, 0, NULL), -1, EFAULT); break; 826b4844fa0SWilly Tarreau case __LINE__: 827b4844fa0SWilly Tarreau return ret; /* must be last */ 828b4844fa0SWilly Tarreau /* note: do not set any defaults so as to permit holes above */ 829b4844fa0SWilly Tarreau } 830b4844fa0SWilly Tarreau } 831b4844fa0SWilly Tarreau return ret; 832b4844fa0SWilly Tarreau } 833b4844fa0SWilly Tarreau 83495bc9894SWilly Tarreau int run_stdlib(int min, int max) 83595bc9894SWilly Tarreau { 83695bc9894SWilly Tarreau int test; 83795bc9894SWilly Tarreau int tmp; 83895bc9894SWilly Tarreau int ret = 0; 83995bc9894SWilly Tarreau void *p1, *p2; 84095bc9894SWilly Tarreau 84195bc9894SWilly Tarreau for (test = min; test >= 0 && test <= max; test++) { 842fddc8f81SThomas Weißschuh int llen = 0; /* line length */ 84395bc9894SWilly Tarreau 84495bc9894SWilly Tarreau /* avoid leaving empty lines below, this will insert holes into 84595bc9894SWilly Tarreau * test numbers. 84695bc9894SWilly Tarreau */ 84795bc9894SWilly Tarreau switch (test + __LINE__ + 1) { 84867d108e2SThomas Weißschuh CASE_TEST(environ); EXPECT_PTREQ(1, environ, test_envp); break; 84995bc9894SWilly Tarreau CASE_TEST(getenv_TERM); EXPECT_STRNZ(1, getenv("TERM")); break; 85095bc9894SWilly Tarreau CASE_TEST(getenv_blah); EXPECT_STRZR(1, getenv("blah")); break; 85195bc9894SWilly Tarreau CASE_TEST(setcmp_blah_blah); EXPECT_EQ(1, strcmp("blah", "blah"), 0); break; 85295bc9894SWilly Tarreau CASE_TEST(setcmp_blah_blah2); EXPECT_NE(1, strcmp("blah", "blah2"), 0); break; 85395bc9894SWilly Tarreau CASE_TEST(setncmp_blah_blah); EXPECT_EQ(1, strncmp("blah", "blah", 10), 0); break; 85495bc9894SWilly Tarreau CASE_TEST(setncmp_blah_blah4); EXPECT_EQ(1, strncmp("blah", "blah4", 4), 0); break; 85595bc9894SWilly Tarreau CASE_TEST(setncmp_blah_blah5); EXPECT_NE(1, strncmp("blah", "blah5", 5), 0); break; 85695bc9894SWilly Tarreau CASE_TEST(setncmp_blah_blah6); EXPECT_NE(1, strncmp("blah", "blah6", 6), 0); break; 85795bc9894SWilly Tarreau CASE_TEST(strchr_foobar_o); EXPECT_STREQ(1, strchr("foobar", 'o'), "oobar"); break; 85895bc9894SWilly Tarreau CASE_TEST(strchr_foobar_z); EXPECT_STRZR(1, strchr("foobar", 'z')); break; 85995bc9894SWilly Tarreau CASE_TEST(strrchr_foobar_o); EXPECT_STREQ(1, strrchr("foobar", 'o'), "obar"); break; 86095bc9894SWilly Tarreau CASE_TEST(strrchr_foobar_z); EXPECT_STRZR(1, strrchr("foobar", 'z')); break; 861c80b5a0aSWilly Tarreau CASE_TEST(memcmp_20_20); EXPECT_EQ(1, memcmp("aaa\x20", "aaa\x20", 4), 0); break; 862c80b5a0aSWilly Tarreau CASE_TEST(memcmp_20_60); EXPECT_LT(1, memcmp("aaa\x20", "aaa\x60", 4), 0); break; 863c80b5a0aSWilly Tarreau CASE_TEST(memcmp_60_20); EXPECT_GT(1, memcmp("aaa\x60", "aaa\x20", 4), 0); break; 864c80b5a0aSWilly Tarreau CASE_TEST(memcmp_20_e0); EXPECT_LT(1, memcmp("aaa\x20", "aaa\xe0", 4), 0); break; 865c80b5a0aSWilly Tarreau CASE_TEST(memcmp_e0_20); EXPECT_GT(1, memcmp("aaa\xe0", "aaa\x20", 4), 0); break; 866c80b5a0aSWilly Tarreau CASE_TEST(memcmp_80_e0); EXPECT_LT(1, memcmp("aaa\x80", "aaa\xe0", 4), 0); break; 867c80b5a0aSWilly Tarreau CASE_TEST(memcmp_e0_80); EXPECT_GT(1, memcmp("aaa\xe0", "aaa\x80", 4), 0); break; 868d1209597SVincent Dagonneau CASE_TEST(limit_int8_max); EXPECT_EQ(1, INT8_MAX, (int8_t) 0x7f); break; 869d1209597SVincent Dagonneau CASE_TEST(limit_int8_min); EXPECT_EQ(1, INT8_MIN, (int8_t) 0x80); break; 870d1209597SVincent Dagonneau CASE_TEST(limit_uint8_max); EXPECT_EQ(1, UINT8_MAX, (uint8_t) 0xff); break; 871d1209597SVincent Dagonneau CASE_TEST(limit_int16_max); EXPECT_EQ(1, INT16_MAX, (int16_t) 0x7fff); break; 872d1209597SVincent Dagonneau CASE_TEST(limit_int16_min); EXPECT_EQ(1, INT16_MIN, (int16_t) 0x8000); break; 873d1209597SVincent Dagonneau CASE_TEST(limit_uint16_max); EXPECT_EQ(1, UINT16_MAX, (uint16_t) 0xffff); break; 874d1209597SVincent Dagonneau CASE_TEST(limit_int32_max); EXPECT_EQ(1, INT32_MAX, (int32_t) 0x7fffffff); break; 875d1209597SVincent Dagonneau CASE_TEST(limit_int32_min); EXPECT_EQ(1, INT32_MIN, (int32_t) 0x80000000); break; 876d1209597SVincent Dagonneau CASE_TEST(limit_uint32_max); EXPECT_EQ(1, UINT32_MAX, (uint32_t) 0xffffffff); break; 877d1209597SVincent Dagonneau CASE_TEST(limit_int64_max); EXPECT_EQ(1, INT64_MAX, (int64_t) 0x7fffffffffffffff); break; 878d1209597SVincent Dagonneau CASE_TEST(limit_int64_min); EXPECT_EQ(1, INT64_MIN, (int64_t) 0x8000000000000000); break; 879d1209597SVincent Dagonneau CASE_TEST(limit_uint64_max); EXPECT_EQ(1, UINT64_MAX, (uint64_t) 0xffffffffffffffff); break; 880d1209597SVincent Dagonneau CASE_TEST(limit_int_least8_max); EXPECT_EQ(1, INT_LEAST8_MAX, (int_least8_t) 0x7f); break; 881d1209597SVincent Dagonneau CASE_TEST(limit_int_least8_min); EXPECT_EQ(1, INT_LEAST8_MIN, (int_least8_t) 0x80); break; 882d1209597SVincent Dagonneau CASE_TEST(limit_uint_least8_max); EXPECT_EQ(1, UINT_LEAST8_MAX, (uint_least8_t) 0xff); break; 883d1209597SVincent Dagonneau CASE_TEST(limit_int_least16_max); EXPECT_EQ(1, INT_LEAST16_MAX, (int_least16_t) 0x7fff); break; 884d1209597SVincent Dagonneau CASE_TEST(limit_int_least16_min); EXPECT_EQ(1, INT_LEAST16_MIN, (int_least16_t) 0x8000); break; 885d1209597SVincent Dagonneau CASE_TEST(limit_uint_least16_max); EXPECT_EQ(1, UINT_LEAST16_MAX, (uint_least16_t) 0xffff); break; 886d1209597SVincent Dagonneau CASE_TEST(limit_int_least32_max); EXPECT_EQ(1, INT_LEAST32_MAX, (int_least32_t) 0x7fffffff); break; 887d1209597SVincent Dagonneau CASE_TEST(limit_int_least32_min); EXPECT_EQ(1, INT_LEAST32_MIN, (int_least32_t) 0x80000000); break; 888d1209597SVincent Dagonneau CASE_TEST(limit_uint_least32_max); EXPECT_EQ(1, UINT_LEAST32_MAX, (uint_least32_t) 0xffffffffU); break; 889d1209597SVincent Dagonneau CASE_TEST(limit_int_least64_min); EXPECT_EQ(1, INT_LEAST64_MIN, (int_least64_t) 0x8000000000000000LL); break; 890d1209597SVincent Dagonneau CASE_TEST(limit_int_least64_max); EXPECT_EQ(1, INT_LEAST64_MAX, (int_least64_t) 0x7fffffffffffffffLL); break; 891d1209597SVincent Dagonneau CASE_TEST(limit_uint_least64_max); EXPECT_EQ(1, UINT_LEAST64_MAX, (uint_least64_t) 0xffffffffffffffffULL); break; 892d1209597SVincent Dagonneau CASE_TEST(limit_int_fast8_max); EXPECT_EQ(1, INT_FAST8_MAX, (int_fast8_t) 0x7f); break; 893d1209597SVincent Dagonneau CASE_TEST(limit_int_fast8_min); EXPECT_EQ(1, INT_FAST8_MIN, (int_fast8_t) 0x80); break; 894d1209597SVincent Dagonneau CASE_TEST(limit_uint_fast8_max); EXPECT_EQ(1, UINT_FAST8_MAX, (uint_fast8_t) 0xff); break; 895989abf1cSZhangjin Wu CASE_TEST(limit_int_fast16_min); EXPECT_EQ(1, INT_FAST16_MIN, (int_fast16_t) SINT_MIN_OF_TYPE(int_fast16_t)); break; 896989abf1cSZhangjin Wu CASE_TEST(limit_int_fast16_max); EXPECT_EQ(1, INT_FAST16_MAX, (int_fast16_t) SINT_MAX_OF_TYPE(int_fast16_t)); break; 897d1209597SVincent Dagonneau CASE_TEST(limit_uint_fast16_max); EXPECT_EQ(1, UINT_FAST16_MAX, (uint_fast16_t) UINTPTR_MAX); break; 898989abf1cSZhangjin Wu CASE_TEST(limit_int_fast32_min); EXPECT_EQ(1, INT_FAST32_MIN, (int_fast32_t) SINT_MIN_OF_TYPE(int_fast32_t)); break; 899989abf1cSZhangjin Wu CASE_TEST(limit_int_fast32_max); EXPECT_EQ(1, INT_FAST32_MAX, (int_fast32_t) SINT_MAX_OF_TYPE(int_fast32_t)); break; 900d1209597SVincent Dagonneau CASE_TEST(limit_uint_fast32_max); EXPECT_EQ(1, UINT_FAST32_MAX, (uint_fast32_t) UINTPTR_MAX); break; 901f9bf5944SThomas Weißschuh CASE_TEST(limit_int_fast64_min); EXPECT_EQ(1, INT_FAST64_MIN, (int_fast64_t) INT64_MIN); break; 902f9bf5944SThomas Weißschuh CASE_TEST(limit_int_fast64_max); EXPECT_EQ(1, INT_FAST64_MAX, (int_fast64_t) INT64_MAX); break; 903f9bf5944SThomas Weißschuh CASE_TEST(limit_uint_fast64_max); EXPECT_EQ(1, UINT_FAST64_MAX, (uint_fast64_t) UINT64_MAX); break; 904ceb528feSThomas Weißschuh CASE_TEST(sizeof_long_sane); EXPECT_EQ(1, sizeof(long) == 8 || sizeof(long) == 4, 1); break; 905ceb528feSThomas Weißschuh CASE_TEST(limit_intptr_min_64); EXPECT_EQ(sizeof(long) == 8, INTPTR_MIN, (intptr_t) 0x8000000000000000LL); break; 906ceb528feSThomas Weißschuh CASE_TEST(limit_intptr_max_64); EXPECT_EQ(sizeof(long) == 8, INTPTR_MAX, (intptr_t) 0x7fffffffffffffffLL); break; 907ceb528feSThomas Weißschuh CASE_TEST(limit_uintptr_max_64); EXPECT_EQ(sizeof(long) == 8, UINTPTR_MAX, (uintptr_t) 0xffffffffffffffffULL); break; 908ceb528feSThomas Weißschuh CASE_TEST(limit_ptrdiff_min_64); EXPECT_EQ(sizeof(long) == 8, PTRDIFF_MIN, (ptrdiff_t) 0x8000000000000000LL); break; 909ceb528feSThomas Weißschuh CASE_TEST(limit_ptrdiff_max_64); EXPECT_EQ(sizeof(long) == 8, PTRDIFF_MAX, (ptrdiff_t) 0x7fffffffffffffffLL); break; 910ceb528feSThomas Weißschuh CASE_TEST(limit_size_max_64); EXPECT_EQ(sizeof(long) == 8, SIZE_MAX, (size_t) 0xffffffffffffffffULL); break; 911ceb528feSThomas Weißschuh CASE_TEST(limit_intptr_min_32); EXPECT_EQ(sizeof(long) == 4, INTPTR_MIN, (intptr_t) 0x80000000); break; 912ceb528feSThomas Weißschuh CASE_TEST(limit_intptr_max_32); EXPECT_EQ(sizeof(long) == 4, INTPTR_MAX, (intptr_t) 0x7fffffff); break; 913ceb528feSThomas Weißschuh CASE_TEST(limit_uintptr_max_32); EXPECT_EQ(sizeof(long) == 4, UINTPTR_MAX, (uintptr_t) 0xffffffffU); break; 914ceb528feSThomas Weißschuh CASE_TEST(limit_ptrdiff_min_32); EXPECT_EQ(sizeof(long) == 4, PTRDIFF_MIN, (ptrdiff_t) 0x80000000); break; 915ceb528feSThomas Weißschuh CASE_TEST(limit_ptrdiff_max_32); EXPECT_EQ(sizeof(long) == 4, PTRDIFF_MAX, (ptrdiff_t) 0x7fffffff); break; 916ceb528feSThomas Weißschuh CASE_TEST(limit_size_max_32); EXPECT_EQ(sizeof(long) == 4, SIZE_MAX, (size_t) 0xffffffffU); break; 91795bc9894SWilly Tarreau case __LINE__: 91895bc9894SWilly Tarreau return ret; /* must be last */ 91995bc9894SWilly Tarreau /* note: do not set any defaults so as to permit holes above */ 92095bc9894SWilly Tarreau } 92195bc9894SWilly Tarreau } 92295bc9894SWilly Tarreau return ret; 92395bc9894SWilly Tarreau } 92495bc9894SWilly Tarreau 92569f2cd9fSThomas Weißschuh #define EXPECT_VFPRINTF(c, expected, fmt, ...) \ 92669f2cd9fSThomas Weißschuh ret += expect_vfprintf(llen, c, expected, fmt, ##__VA_ARGS__) 92769f2cd9fSThomas Weißschuh 92869f2cd9fSThomas Weißschuh static int expect_vfprintf(int llen, size_t c, const char *expected, const char *fmt, ...) 92969f2cd9fSThomas Weißschuh { 93069f2cd9fSThomas Weißschuh int ret, fd, w, r; 93169f2cd9fSThomas Weißschuh char buf[100]; 93269f2cd9fSThomas Weißschuh FILE *memfile; 93369f2cd9fSThomas Weißschuh va_list args; 93469f2cd9fSThomas Weißschuh 9356861b1a3SZhangjin Wu fd = open("/tmp", O_TMPFILE | O_EXCL | O_RDWR, 0600); 93669f2cd9fSThomas Weißschuh if (fd == -1) { 937b184a261SThomas Weißschuh result(llen, SKIPPED); 9386861b1a3SZhangjin Wu return 0; 93969f2cd9fSThomas Weißschuh } 94069f2cd9fSThomas Weißschuh 94169f2cd9fSThomas Weißschuh memfile = fdopen(fd, "w+"); 94269f2cd9fSThomas Weißschuh if (!memfile) { 943b184a261SThomas Weißschuh result(llen, FAIL); 94469f2cd9fSThomas Weißschuh return 1; 94569f2cd9fSThomas Weißschuh } 94669f2cd9fSThomas Weißschuh 94769f2cd9fSThomas Weißschuh va_start(args, fmt); 94869f2cd9fSThomas Weißschuh w = vfprintf(memfile, fmt, args); 94969f2cd9fSThomas Weißschuh va_end(args); 95069f2cd9fSThomas Weißschuh 95169f2cd9fSThomas Weißschuh if (w != c) { 95269f2cd9fSThomas Weißschuh llen += printf(" written(%d) != %d", w, (int) c); 953b184a261SThomas Weißschuh result(llen, FAIL); 95469f2cd9fSThomas Weißschuh return 1; 95569f2cd9fSThomas Weißschuh } 95669f2cd9fSThomas Weißschuh 95769f2cd9fSThomas Weißschuh fflush(memfile); 95869f2cd9fSThomas Weißschuh lseek(fd, 0, SEEK_SET); 95969f2cd9fSThomas Weißschuh 96069f2cd9fSThomas Weißschuh r = read(fd, buf, sizeof(buf) - 1); 96169f2cd9fSThomas Weißschuh buf[r] = '\0'; 96269f2cd9fSThomas Weißschuh 96369f2cd9fSThomas Weißschuh fclose(memfile); 96469f2cd9fSThomas Weißschuh 96569f2cd9fSThomas Weißschuh if (r != w) { 96669f2cd9fSThomas Weißschuh llen += printf(" written(%d) != read(%d)", w, r); 967b184a261SThomas Weißschuh result(llen, FAIL); 96869f2cd9fSThomas Weißschuh return 1; 96969f2cd9fSThomas Weißschuh } 97069f2cd9fSThomas Weißschuh 97169f2cd9fSThomas Weißschuh llen += printf(" \"%s\" = \"%s\"", expected, buf); 97269f2cd9fSThomas Weißschuh ret = strncmp(expected, buf, c); 97369f2cd9fSThomas Weißschuh 974b184a261SThomas Weißschuh result(llen, ret ? FAIL : OK); 97569f2cd9fSThomas Weißschuh return ret; 97669f2cd9fSThomas Weißschuh } 97769f2cd9fSThomas Weißschuh 97869f2cd9fSThomas Weißschuh static int run_vfprintf(int min, int max) 97969f2cd9fSThomas Weißschuh { 98069f2cd9fSThomas Weißschuh int test; 98169f2cd9fSThomas Weißschuh int tmp; 98269f2cd9fSThomas Weißschuh int ret = 0; 98369f2cd9fSThomas Weißschuh void *p1, *p2; 98469f2cd9fSThomas Weißschuh 98569f2cd9fSThomas Weißschuh for (test = min; test >= 0 && test <= max; test++) { 986fddc8f81SThomas Weißschuh int llen = 0; /* line length */ 98769f2cd9fSThomas Weißschuh 98869f2cd9fSThomas Weißschuh /* avoid leaving empty lines below, this will insert holes into 98969f2cd9fSThomas Weißschuh * test numbers. 99069f2cd9fSThomas Weißschuh */ 99169f2cd9fSThomas Weißschuh switch (test + __LINE__ + 1) { 99269f2cd9fSThomas Weißschuh CASE_TEST(empty); EXPECT_VFPRINTF(0, "", ""); break; 99369f2cd9fSThomas Weißschuh CASE_TEST(simple); EXPECT_VFPRINTF(3, "foo", "foo"); break; 99469f2cd9fSThomas Weißschuh CASE_TEST(string); EXPECT_VFPRINTF(3, "foo", "%s", "foo"); break; 99569f2cd9fSThomas Weißschuh CASE_TEST(number); EXPECT_VFPRINTF(4, "1234", "%d", 1234); break; 99669f2cd9fSThomas Weißschuh CASE_TEST(negnumber); EXPECT_VFPRINTF(5, "-1234", "%d", -1234); break; 99769f2cd9fSThomas Weißschuh CASE_TEST(unsigned); EXPECT_VFPRINTF(5, "12345", "%u", 12345); break; 99869f2cd9fSThomas Weißschuh CASE_TEST(char); EXPECT_VFPRINTF(1, "c", "%c", 'c'); break; 99969f2cd9fSThomas Weißschuh CASE_TEST(hex); EXPECT_VFPRINTF(1, "f", "%x", 0xf); break; 100069f2cd9fSThomas Weißschuh CASE_TEST(pointer); EXPECT_VFPRINTF(3, "0x1", "%p", (void *) 0x1); break; 100169f2cd9fSThomas Weißschuh case __LINE__: 100269f2cd9fSThomas Weißschuh return ret; /* must be last */ 100369f2cd9fSThomas Weißschuh /* note: do not set any defaults so as to permit holes above */ 100469f2cd9fSThomas Weißschuh } 100569f2cd9fSThomas Weißschuh } 100669f2cd9fSThomas Weißschuh return ret; 100769f2cd9fSThomas Weißschuh } 100869f2cd9fSThomas Weißschuh 100997357168SThomas Weißschuh static int smash_stack(void) 101097357168SThomas Weißschuh { 101197357168SThomas Weißschuh char buf[100]; 1012e7654c3fSThomas Weißschuh volatile char *ptr = buf; 1013aa662d12SWilly Tarreau size_t i; 101497357168SThomas Weißschuh 1015aa662d12SWilly Tarreau for (i = 0; i < 200; i++) 1016e7654c3fSThomas Weißschuh ptr[i] = 'P'; 101797357168SThomas Weißschuh 101897357168SThomas Weißschuh return 1; 101997357168SThomas Weißschuh } 102097357168SThomas Weißschuh 102197357168SThomas Weißschuh static int run_protection(int min, int max) 102297357168SThomas Weißschuh { 102397357168SThomas Weißschuh pid_t pid; 102497357168SThomas Weißschuh int llen = 0, status; 102597357168SThomas Weißschuh 102697357168SThomas Weißschuh llen += printf("0 -fstackprotector "); 102797357168SThomas Weißschuh 1028818924d1SThomas Weißschuh #if !defined(_NOLIBC_STACKPROTECTOR) 102997357168SThomas Weißschuh llen += printf("not supported"); 1030b184a261SThomas Weißschuh result(llen, SKIPPED); 103197357168SThomas Weißschuh return 0; 103297357168SThomas Weißschuh #endif 103397357168SThomas Weißschuh 1034818924d1SThomas Weißschuh #if defined(_NOLIBC_STACKPROTECTOR) 103585250921SThomas Weißschuh if (!__stack_chk_guard) { 103685250921SThomas Weißschuh llen += printf("__stack_chk_guard not initialized"); 1037b184a261SThomas Weißschuh result(llen, FAIL); 103885250921SThomas Weißschuh return 1; 103985250921SThomas Weißschuh } 104085250921SThomas Weißschuh #endif 104185250921SThomas Weißschuh 104297357168SThomas Weißschuh pid = -1; 104397357168SThomas Weißschuh pid = fork(); 104497357168SThomas Weißschuh 104597357168SThomas Weißschuh switch (pid) { 104697357168SThomas Weißschuh case -1: 104797357168SThomas Weißschuh llen += printf("fork()"); 1048b184a261SThomas Weißschuh result(llen, FAIL); 104997357168SThomas Weißschuh return 1; 105097357168SThomas Weißschuh 105197357168SThomas Weißschuh case 0: 105297357168SThomas Weißschuh close(STDOUT_FILENO); 105397357168SThomas Weißschuh close(STDERR_FILENO); 105497357168SThomas Weißschuh 10559a75575bSThomas Weißschuh prctl(PR_SET_DUMPABLE, 0, 0, 0, 0); 105697357168SThomas Weißschuh smash_stack(); 105797357168SThomas Weißschuh return 1; 105897357168SThomas Weißschuh 105997357168SThomas Weißschuh default: 106097357168SThomas Weißschuh pid = waitpid(pid, &status, 0); 106197357168SThomas Weißschuh 106297357168SThomas Weißschuh if (pid == -1 || !WIFSIGNALED(status) || WTERMSIG(status) != SIGABRT) { 106397357168SThomas Weißschuh llen += printf("waitpid()"); 1064b184a261SThomas Weißschuh result(llen, FAIL); 106597357168SThomas Weißschuh return 1; 106697357168SThomas Weißschuh } 1067b184a261SThomas Weißschuh result(llen, OK); 106897357168SThomas Weißschuh return 0; 106997357168SThomas Weißschuh } 107097357168SThomas Weißschuh } 107197357168SThomas Weißschuh 10721a5454f6SWilly Tarreau /* prepare what needs to be prepared for pid 1 (stdio, /dev, /proc, etc) */ 10731a5454f6SWilly Tarreau int prepare(void) 10741a5454f6SWilly Tarreau { 10751a5454f6SWilly Tarreau struct stat stat_buf; 10761a5454f6SWilly Tarreau 10771a5454f6SWilly Tarreau /* It's possible that /dev doesn't even exist or was not mounted, so 10781a5454f6SWilly Tarreau * we'll try to create it, mount it, or create minimal entries into it. 10791a5454f6SWilly Tarreau * We want at least /dev/null and /dev/console. 10801a5454f6SWilly Tarreau */ 10811a5454f6SWilly Tarreau if (stat("/dev/.", &stat_buf) == 0 || mkdir("/dev", 0755) == 0) { 10821a5454f6SWilly Tarreau if (stat("/dev/console", &stat_buf) != 0 || 108382e339c2SZhangjin Wu stat("/dev/null", &stat_buf) != 0 || 108482e339c2SZhangjin Wu stat("/dev/zero", &stat_buf) != 0) { 10851a5454f6SWilly Tarreau /* try devtmpfs first, otherwise fall back to manual creation */ 10861a5454f6SWilly Tarreau if (mount("/dev", "/dev", "devtmpfs", 0, 0) != 0) { 10871a5454f6SWilly Tarreau mknod("/dev/console", 0600 | S_IFCHR, makedev(5, 1)); 10881a5454f6SWilly Tarreau mknod("/dev/null", 0666 | S_IFCHR, makedev(1, 3)); 108982e339c2SZhangjin Wu mknod("/dev/zero", 0666 | S_IFCHR, makedev(1, 5)); 10901a5454f6SWilly Tarreau } 10911a5454f6SWilly Tarreau } 10921a5454f6SWilly Tarreau } 10931a5454f6SWilly Tarreau 10941a5454f6SWilly Tarreau /* If no /dev/console was found before calling init, stdio is closed so 10951a5454f6SWilly Tarreau * we need to reopen it from /dev/console. If it failed above, it will 10961a5454f6SWilly Tarreau * still fail here and we cannot emit a message anyway. 10971a5454f6SWilly Tarreau */ 10981a5454f6SWilly Tarreau if (close(dup(1)) == -1) { 10991a5454f6SWilly Tarreau int fd = open("/dev/console", O_RDWR); 11001a5454f6SWilly Tarreau 11011a5454f6SWilly Tarreau if (fd >= 0) { 11021a5454f6SWilly Tarreau if (fd != 0) 11031a5454f6SWilly Tarreau dup2(fd, 0); 11041a5454f6SWilly Tarreau if (fd != 1) 11051a5454f6SWilly Tarreau dup2(fd, 1); 11061a5454f6SWilly Tarreau if (fd != 2) 11071a5454f6SWilly Tarreau dup2(fd, 2); 11081a5454f6SWilly Tarreau if (fd > 2) 11091a5454f6SWilly Tarreau close(fd); 11101a5454f6SWilly Tarreau puts("\nSuccessfully reopened /dev/console."); 11111a5454f6SWilly Tarreau } 11121a5454f6SWilly Tarreau } 11131a5454f6SWilly Tarreau 11141a5454f6SWilly Tarreau /* try to mount /proc if not mounted. Silently fail otherwise */ 11151a5454f6SWilly Tarreau if (stat("/proc/.", &stat_buf) == 0 || mkdir("/proc", 0755) == 0) { 1116b8b26108SZhangjin Wu if (stat("/proc/self", &stat_buf) != 0) { 1117b8b26108SZhangjin Wu /* If not mountable, remove /proc completely to avoid misuse */ 1118b8b26108SZhangjin Wu if (mount("none", "/proc", "proc", 0, 0) != 0) 1119b8b26108SZhangjin Wu rmdir("/proc"); 1120b8b26108SZhangjin Wu } 11211a5454f6SWilly Tarreau } 11221a5454f6SWilly Tarreau 1123bbb14546SZhangjin Wu /* some tests rely on a writable /tmp */ 1124bbb14546SZhangjin Wu mkdir("/tmp", 0755); 1125bbb14546SZhangjin Wu 11261a5454f6SWilly Tarreau return 0; 11271a5454f6SWilly Tarreau } 1128b4844fa0SWilly Tarreau 112923da7bc9SWilly Tarreau /* This is the definition of known test names, with their functions */ 1130c4560bd8SThomas Weißschuh static const struct test test_names[] = { 113123da7bc9SWilly Tarreau /* add new tests here */ 1132b4844fa0SWilly Tarreau { .name = "syscall", .func = run_syscall }, 113395bc9894SWilly Tarreau { .name = "stdlib", .func = run_stdlib }, 113469f2cd9fSThomas Weißschuh { .name = "vfprintf", .func = run_vfprintf }, 113597357168SThomas Weißschuh { .name = "protection", .func = run_protection }, 113623da7bc9SWilly Tarreau { 0 } 113723da7bc9SWilly Tarreau }; 113823da7bc9SWilly Tarreau 1139c388c992SZhangjin Wu int is_setting_valid(char *test) 1140c388c992SZhangjin Wu { 1141c388c992SZhangjin Wu int idx, len, test_len, valid = 0; 1142c388c992SZhangjin Wu char delimiter; 1143c388c992SZhangjin Wu 1144c388c992SZhangjin Wu if (!test) 1145c388c992SZhangjin Wu return valid; 1146c388c992SZhangjin Wu 1147c388c992SZhangjin Wu test_len = strlen(test); 1148c388c992SZhangjin Wu 1149c388c992SZhangjin Wu for (idx = 0; test_names[idx].name; idx++) { 1150c388c992SZhangjin Wu len = strlen(test_names[idx].name); 1151c388c992SZhangjin Wu if (test_len < len) 1152c388c992SZhangjin Wu continue; 1153c388c992SZhangjin Wu 1154c388c992SZhangjin Wu if (strncmp(test, test_names[idx].name, len) != 0) 1155c388c992SZhangjin Wu continue; 1156c388c992SZhangjin Wu 1157c388c992SZhangjin Wu delimiter = test[len]; 1158c388c992SZhangjin Wu if (delimiter != ':' && delimiter != ',' && delimiter != '\0') 1159c388c992SZhangjin Wu continue; 1160c388c992SZhangjin Wu 1161c388c992SZhangjin Wu valid = 1; 1162c388c992SZhangjin Wu break; 1163c388c992SZhangjin Wu } 1164c388c992SZhangjin Wu 1165c388c992SZhangjin Wu return valid; 1166c388c992SZhangjin Wu } 1167c388c992SZhangjin Wu 1168362aecb2SWilly Tarreau int main(int argc, char **argv, char **envp) 1169362aecb2SWilly Tarreau { 1170362aecb2SWilly Tarreau int min = 0; 1171a36cfc5eSZhangjin Wu int max = INT_MAX; 1172362aecb2SWilly Tarreau int ret = 0; 117323da7bc9SWilly Tarreau int err; 117423da7bc9SWilly Tarreau int idx; 117523da7bc9SWilly Tarreau char *test; 1176362aecb2SWilly Tarreau 1177938b5b98SZhangjin Wu argv0 = argv[0]; 117867d108e2SThomas Weißschuh test_envp = envp; 1179362aecb2SWilly Tarreau 11801a5454f6SWilly Tarreau /* when called as init, it's possible that no console was opened, for 11811a5454f6SWilly Tarreau * example if no /dev file system was provided. We'll check that fd#1 11821a5454f6SWilly Tarreau * was opened, and if not we'll attempt to create and open /dev/console 11831a5454f6SWilly Tarreau * and /dev/null that we'll use for later tests. 11841a5454f6SWilly Tarreau */ 11851a5454f6SWilly Tarreau if (getpid() == 1) 11861a5454f6SWilly Tarreau prepare(); 11871a5454f6SWilly Tarreau 118823da7bc9SWilly Tarreau /* the definition of a series of tests comes from either argv[1] or the 118923da7bc9SWilly Tarreau * "NOLIBC_TEST" environment variable. It's made of a comma-delimited 119023da7bc9SWilly Tarreau * series of test names and optional ranges: 119123da7bc9SWilly Tarreau * syscall:5-15[:.*],stdlib:8-10 119223da7bc9SWilly Tarreau */ 119323da7bc9SWilly Tarreau test = argv[1]; 1194c388c992SZhangjin Wu if (!is_setting_valid(test)) 119523da7bc9SWilly Tarreau test = getenv("NOLIBC_TEST"); 119623da7bc9SWilly Tarreau 1197c388c992SZhangjin Wu if (is_setting_valid(test)) { 119823da7bc9SWilly Tarreau char *comma, *colon, *dash, *value; 119923da7bc9SWilly Tarreau 120023da7bc9SWilly Tarreau do { 120123da7bc9SWilly Tarreau comma = strchr(test, ','); 120223da7bc9SWilly Tarreau if (comma) 120323da7bc9SWilly Tarreau *(comma++) = '\0'; 120423da7bc9SWilly Tarreau 120523da7bc9SWilly Tarreau colon = strchr(test, ':'); 120623da7bc9SWilly Tarreau if (colon) 120723da7bc9SWilly Tarreau *(colon++) = '\0'; 120823da7bc9SWilly Tarreau 120923da7bc9SWilly Tarreau for (idx = 0; test_names[idx].name; idx++) { 121023da7bc9SWilly Tarreau if (strcmp(test, test_names[idx].name) == 0) 121123da7bc9SWilly Tarreau break; 121223da7bc9SWilly Tarreau } 121323da7bc9SWilly Tarreau 121423da7bc9SWilly Tarreau if (test_names[idx].name) { 121523da7bc9SWilly Tarreau /* The test was named, it will be called at least 121623da7bc9SWilly Tarreau * once. We may have an optional range at <colon> 121723da7bc9SWilly Tarreau * here, which defaults to the full range. 121823da7bc9SWilly Tarreau */ 121923da7bc9SWilly Tarreau do { 1220a36cfc5eSZhangjin Wu min = 0; max = INT_MAX; 122123da7bc9SWilly Tarreau value = colon; 122223da7bc9SWilly Tarreau if (value && *value) { 122323da7bc9SWilly Tarreau colon = strchr(value, ':'); 122423da7bc9SWilly Tarreau if (colon) 122523da7bc9SWilly Tarreau *(colon++) = '\0'; 122623da7bc9SWilly Tarreau 122723da7bc9SWilly Tarreau dash = strchr(value, '-'); 122823da7bc9SWilly Tarreau if (dash) 122923da7bc9SWilly Tarreau *(dash++) = '\0'; 123023da7bc9SWilly Tarreau 123123da7bc9SWilly Tarreau /* support :val: :min-max: :min-: :-max: */ 123223da7bc9SWilly Tarreau if (*value) 123323da7bc9SWilly Tarreau min = atoi(value); 123423da7bc9SWilly Tarreau if (!dash) 123523da7bc9SWilly Tarreau max = min; 123623da7bc9SWilly Tarreau else if (*dash) 123723da7bc9SWilly Tarreau max = atoi(dash); 123823da7bc9SWilly Tarreau 123923da7bc9SWilly Tarreau value = colon; 124023da7bc9SWilly Tarreau } 124123da7bc9SWilly Tarreau 124223da7bc9SWilly Tarreau /* now's time to call the test */ 124323da7bc9SWilly Tarreau printf("Running test '%s'\n", test_names[idx].name); 124423da7bc9SWilly Tarreau err = test_names[idx].func(min, max); 124523da7bc9SWilly Tarreau ret += err; 124623da7bc9SWilly Tarreau printf("Errors during this test: %d\n\n", err); 124723da7bc9SWilly Tarreau } while (colon && *colon); 124823da7bc9SWilly Tarreau } else 124923da7bc9SWilly Tarreau printf("Ignoring unknown test name '%s'\n", test); 125023da7bc9SWilly Tarreau 125123da7bc9SWilly Tarreau test = comma; 125223da7bc9SWilly Tarreau } while (test && *test); 125323da7bc9SWilly Tarreau } else { 125423da7bc9SWilly Tarreau /* no test mentioned, run everything */ 125523da7bc9SWilly Tarreau for (idx = 0; test_names[idx].name; idx++) { 125623da7bc9SWilly Tarreau printf("Running test '%s'\n", test_names[idx].name); 125723da7bc9SWilly Tarreau err = test_names[idx].func(min, max); 125823da7bc9SWilly Tarreau ret += err; 125923da7bc9SWilly Tarreau printf("Errors during this test: %d\n\n", err); 126023da7bc9SWilly Tarreau } 126123da7bc9SWilly Tarreau } 126223da7bc9SWilly Tarreau 1263362aecb2SWilly Tarreau printf("Total number of errors: %d\n", ret); 1264f49896d7SWilly Tarreau 1265f49896d7SWilly Tarreau if (getpid() == 1) { 1266f49896d7SWilly Tarreau /* we're running as init, there's no other process on the 1267f49896d7SWilly Tarreau * system, thus likely started from a VM for a quick check. 1268f49896d7SWilly Tarreau * Exiting will provoke a kernel panic that may be reported 1269f49896d7SWilly Tarreau * as an error by Qemu or the hypervisor, while stopping 1270f49896d7SWilly Tarreau * cleanly will often be reported as a success. This allows 1271f49896d7SWilly Tarreau * to use the output of this program for bisecting kernels. 1272f49896d7SWilly Tarreau */ 1273f49896d7SWilly Tarreau printf("Leaving init with final status: %d\n", !!ret); 1274f49896d7SWilly Tarreau if (ret == 0) 1275950add28SZhangjin Wu reboot(RB_POWER_OFF); 1276aa73a86cSWilly Tarreau #if defined(__x86_64__) 1277aa73a86cSWilly Tarreau /* QEMU started with "-device isa-debug-exit -no-reboot" will 1278aa73a86cSWilly Tarreau * exit with status code 2N+1 when N is written to 0x501. We 1279aa73a86cSWilly Tarreau * hard-code the syscall here as it's arch-dependent. 1280aa73a86cSWilly Tarreau */ 128167eb617aSThomas Weißschuh else if (syscall(__NR_ioperm, 0x501, 1, 1) == 0) 12827f291cfaSThomas Weißschuh __asm__ volatile ("outb %%al, %%dx" :: "d"(0x501), "a"(0)); 1283aa73a86cSWilly Tarreau /* if it does nothing, fall back to the regular panic */ 1284aa73a86cSWilly Tarreau #endif 1285f49896d7SWilly Tarreau } 1286f49896d7SWilly Tarreau 1287362aecb2SWilly Tarreau printf("Exiting with status %d\n", !!ret); 1288362aecb2SWilly Tarreau return !!ret; 1289362aecb2SWilly Tarreau } 1290