configure

   1 #!/bin/sh
   2 #
   3 # Fio configure script. Heavily influenced by the manual qemu configure
   4 # script. Sad this is easier than autoconf and enemies.
   5 #
   6
   7 # set temporary file name
   8 if test ! -z "$TMPDIR" ; then
   9     TMPDIR1="${TMPDIR}"
  10 elif test ! -z "$TEMPDIR" ; then
  11     TMPDIR1="${TEMPDIR}"
  12 else
  13     TMPDIR1="/tmp"
  14 fi
  15
  16 TMPC="${TMPDIR1}/fio-conf-${RANDOM}-$$-${RANDOM}.c"
  17 TMPC2="${TMPDIR1}/fio-conf-${RANDOM}-$$-${RANDOM}-2.c"
  18 TMPO="${TMPDIR1}/fio-conf-${RANDOM}-$$-${RANDOM}.o"
  19 TMPE="${TMPDIR1}/fio-conf-${RANDOM}-$$-${RANDOM}.exe"
  20
  21 # NB: do not call "exit" in the trap handler; this is buggy with some shells;
  22 # see <1285349658-3122-1-git-send-email-loic.minier@linaro.org>
  23 trap "rm -f $TMPC $TMPC2 $TMPO $TMPE" EXIT INT QUIT TERM
  24
  25 rm -rf config.log
  26
  27 config_host_mak="config-host.mak"
  28 config_host_h="config-host.h"
  29
  30 rm -rf $config_host_mak
  31 rm -rf $config_host_h
  32
  33 fatal() {
  34   echo $@
  35   echo "Configure failed, check config.log and/or the above output"
  36   rm -rf $config_host_mak
  37   rm -rf $config_host_h
  38   exit 1
  39 }
  40
  41 # Print result for each configuration test
  42 print_config() {
  43   printf "%-30s%s\n" "$1" "$2"
  44 }
  45
  46 # Default CFLAGS
  47 CFLAGS="-D_GNU_SOURCE -include config-host.h $CFLAGS"
  48 CONFIGURE_CFLAGS="-Werror-implicit-function-declaration"
  49 BUILD_CFLAGS=""
  50
  51 # Print a helpful header at the top of config.log
  52 echo "# FIO configure log $(date)" >> config.log
  53 printf "# Configured with:" >> config.log
  54 printf " '%s'" "$0" "$@" >> config.log
  55 echo >> config.log
  56 echo "#" >> config.log
  57
  58 # Print configure header at the top of $config_host_h
  59 echo "/*" > $config_host_h
  60 echo " * Automatically generated by configure - do not modify" >> $config_host_h
  61 printf " * Configured with:" >> $config_host_h
  62 printf " * '%s'" "$0" "$@" >> $config_host_h
  63 echo "" >> $config_host_h
  64 echo " */" >> $config_host_h
  65
  66 do_cc() {
  67     # Run the compiler, capturing its output to the log.
  68     echo $cc "$@" >> config.log
  69     $cc "$@" >> config.log 2>&1 || return $?
  70     # Test passed. If this is an --enable-werror build, rerun
  71     # the test with -Werror and bail out if it fails. This
  72     # makes warning-generating-errors in configure test code
  73     # obvious to developers.
  74     if test "$werror" != "yes"; then
  75         return 0
  76     fi
  77     # Don't bother rerunning the compile if we were already using -Werror
  78     case "$*" in
  79         *-Werror*)
  80            return 0
  81         ;;
  82     esac
  83     echo $cc -Werror "$@" >> config.log
  84     $cc -Werror "$@" >> config.log 2>&1 && return $?
  85     echo "ERROR: configure test passed without -Werror but failed with -Werror."
  86     echo "This is probably a bug in the configure script. The failing command"
  87     echo "will be at the bottom of config.log."
  88     fatal "You can run configure with --disable-werror to bypass this check."
  89 }
  90
  91 compile_object() {
  92   do_cc $CFLAGS $CONFIGURE_CFLAGS -c -o $TMPO $TMPC
  93 }
  94
  95 compile_prog() {
  96   local_cflags="$1"
  97   local_ldflags="$2 $LIBS"
  98   echo "Compiling test case $3" >> config.log
  99   do_cc $CFLAGS $CONFIGURE_CFLAGS $local_cflags -o $TMPE $TMPC $LDFLAGS $local_ldflags
 100 }
 101
 102 feature_not_found() {
 103   feature=$1
 104   packages=$2
 105
 106   echo "ERROR"
 107   echo "ERROR: User requested feature $feature"
 108   if test ! -z "$packages" ; then
 109     echo "ERROR: That feature needs $packages installed"
 110   fi
 111   echo "ERROR: configure was not able to find it"
 112   fatal "ERROR"
 113 }
 114
 115 has() {
 116   type "$1" >/dev/null 2>&1
 117 }
 118
 119 num() {
 120   echo "$1" | grep -E -q "^[0-9]+$"
 121 }
 122
 123 check_define() {
 124   cat > $TMPC <<EOF
 125 #if !defined($1)
 126 #error $1 not defined
 127 #endif
 128 int main(void)
 129 {
 130   return 0;
 131 }
 132 EOF
 133   compile_object
 134 }
 135
 136 check_val() {
 137     cat > $TMPC <<EOF
 138 #if $1 == $2
 139 int main(void)
 140 {
 141   return 0;
 142 }
 143 #else
 144 #error $1 is not equal $2
 145 #endif
 146 EOF
 147   compile_object
 148 }
 149
 150 output_sym() {
 151   echo "$1=y" >> $config_host_mak
 152   echo "#define $1" >> $config_host_h
 153 }
 154
 155 check_min_lib_version() {
 156   _feature=$3
 157
 158   if "${cross_prefix}"pkg-config --atleast-version="$2" "$1" > /dev/null 2>&1; then
 159     return 0
 160   fi
 161   : "${_feature:=${1}}"
 162   if "${cross_prefix}"pkg-config --version > /dev/null 2>&1; then
 163     if test "$(eval echo \"\$$_feature\")" = "yes" ; then
 164       feature_not_found "$_feature" "$1 >= $2"
 165     fi
 166   else
 167     print_config "$1" "missing pkg-config, can't check $_feature version"
 168   fi
 169   return 1
 170 }
 171
 172 targetos=""
 173 cpu=""
 174
 175 # default options
 176 show_help="no"
 177 exit_val=0
 178 gfio_check="no"
 179 libhdfs="no"
 180 devdax="no"
 181 pmem="no"
 182 cuda="no"
 183 libcufile="no"
 184 disable_lex=""
 185 disable_pmem="no"
 186 disable_native="no"
 187 march_set="no"
 188 libiscsi="no"
 189 libnbd="no"
 190 libnfs=""
 191 xnvme=""
 192 libblkio=""
 193 libzbc=""
 194 dfs=""
 195 seed_buckets=""
 196 dynamic_engines="no"
 197 prefix=/usr/local
 198
 199 # parse options
 200 for opt do
 201   optarg=`expr "x$opt" : 'x[^=]*=\(.*\)'`
 202   case "$opt" in
 203   --prefix=*) prefix="$optarg"
 204   ;;
 205   --cpu=*) cpu="$optarg"
 206   ;;
 207   #  esx is cross compiled and cannot be detect through simple uname calls
 208   --esx)
 209   esx="yes"
 210   ;;
 211   --cc=*) CC="$optarg"
 212   ;;
 213   --extra-cflags=*) CFLAGS="$CFLAGS $optarg"
 214   ;;
 215   --build-32bit-win) build_32bit_win="yes"
 216   ;;
 217   --target-win-ver=*) target_win_ver="$optarg"
 218   ;;
 219   --enable-pdb) pdb="yes"
 220   ;;
 221   --build-static) build_static="yes"
 222   ;;
 223   --enable-gfio) gfio_check="yes"
 224   ;;
 225   --disable-numa) disable_numa="yes"
 226   ;;
 227   --disable-rdma) disable_rdma="yes"
 228   ;;
 229   --disable-rados) disable_rados="yes"
 230   ;;
 231   --disable-rbd) disable_rbd="yes"
 232   ;;
 233   --disable-http) disable_http="yes"
 234   ;;
 235   --disable-gfapi) disable_gfapi="yes"
 236   ;;
 237   --enable-libhdfs) libhdfs="yes"
 238   ;;
 239   --disable-lex) disable_lex="yes"
 240   ;;
 241   --enable-lex) disable_lex="no"
 242   ;;
 243   --disable-shm) no_shm="yes"
 244   ;;
 245   --disable-optimizations) disable_opt="yes"
 246   ;;
 247   --disable-pmem) disable_pmem="yes"
 248   ;;
 249   --enable-cuda) cuda="yes"
 250   ;;
 251   --enable-libcufile) libcufile="yes"
 252   ;;
 253   --disable-native) disable_native="yes"
 254   ;;
 255   --with-ime=*) ime_path="$optarg"
 256   ;;
 257   --enable-libiscsi) libiscsi="yes"
 258   ;;
 259   --enable-libnbd) libnbd="yes"
 260   ;;
 261   --disable-libzbc) libzbc="no"
 262   ;;
 263   --disable-xnvme) xnvme="no"
 264   ;;
 265   --disable-libblkio) libblkio="no"
 266   ;;
 267   --disable-tcmalloc) disable_tcmalloc="yes"
 268   ;;
 269   --disable-libnfs) libnfs="no"
 270   ;;
 271   --enable-libnfs) libnfs="yes"
 272   ;;
 273   --dynamic-libengines) dynamic_engines="yes"
 274   ;;
 275   --disable-dfs) dfs="no"
 276   ;;
 277   --enable-asan) asan="yes"
 278   ;;
 279   --seed-buckets=*) seed_buckets="$optarg"
 280   ;;
 281   --disable-tls) tls_check="no"
 282   ;;
 283   --help)
 284     show_help="yes"
 285     ;;
 286   *)
 287   echo "Bad option $opt"
 288   show_help="yes"
 289   exit_val=1
 290   esac
 291 done
 292
 293 if test "$show_help" = "yes" ; then
 294   echo "--prefix=               Use this directory as installation prefix"
 295   echo "--cpu=                  Specify target CPU if auto-detect fails"
 296   echo "--cc=                   Specify compiler to use"
 297   echo "--extra-cflags=         Specify extra CFLAGS to pass to compiler"
 298   echo "--build-32bit-win       Enable 32-bit build on Windows"
 299   echo "--target-win-ver=       Minimum version of Windows to target (only accepts 7)"
 300   echo "--enable-pdb            Enable Windows PDB symbols generation (needs clang/lld)"
 301   echo "--build-static          Build a static fio"
 302   echo "--esx                   Configure build options for esx"
 303   echo "--enable-gfio           Enable building of gtk gfio"
 304   echo "--disable-numa          Disable libnuma even if found"
 305   echo "--disable-rdma          Disable RDMA support even if found"
 306   echo "--disable-rados         Disable Rados support even if found"
 307   echo "--disable-rbd           Disable Rados Block Device even if found"
 308   echo "--disable-http          Disable HTTP support even if found"
 309   echo "--disable-gfapi         Disable gfapi"
 310   echo "--enable-libhdfs        Enable hdfs support"
 311   echo "--enable-libnfs         Enable nfs support"
 312   echo "--disable-libnfs        Disable nfs support"
 313   echo "--disable-lex           Disable use of lex/yacc for math"
 314   echo "--disable-pmem          Disable pmem based engines even if found"
 315   echo "--enable-lex            Enable use of lex/yacc for math"
 316   echo "--disable-shm           Disable SHM support"
 317   echo "--disable-optimizations Don't enable compiler optimizations"
 318   echo "--enable-cuda           Enable GPUDirect RDMA support"
 319   echo "--enable-libcufile      Enable GPUDirect Storage cuFile support"
 320   echo "--disable-native        Don't build for native host"
 321   echo "--with-ime=             Install path for DDN's Infinite Memory Engine"
 322   echo "--enable-libiscsi       Enable iscsi support"
 323   echo "--enable-libnbd         Enable libnbd (NBD engine) support"
 324   echo "--disable-xnvme         Disable xnvme support even if found"
 325   echo "--disable-libblkio      Disable libblkio support even if found"
 326   echo "--disable-libzbc        Disable libzbc even if found"
 327   echo "--disable-tcmalloc      Disable tcmalloc support"
 328   echo "--dynamic-libengines    Lib-based ioengines as dynamic libraries"
 329   echo "--disable-dfs           Disable DAOS File System support even if found"
 330   echo "--enable-asan           Enable address sanitizer"
 331   echo "--seed-buckets=         Number of seed buckets for the refill-buffer"
 332   echo "--disable-tls           Disable __thread local storage"
 333   exit $exit_val
 334 fi
 335
 336 cross_prefix=${cross_prefix-${CROSS_COMPILE}}
 337 # Preferred compiler (can be overriden later after we know the platform):
 338 #  ${CC} (if set)
 339 #  ${cross_prefix}gcc (if cross-prefix specified)
 340 #  gcc if available
 341 #  clang if available
 342 if test -z "${CC}${cross_prefix}"; then
 343   if has gcc; then
 344     cc=gcc
 345   elif has clang; then
 346     cc=clang
 347   fi
 348 else
 349   cc="${CC-${cross_prefix}gcc}"
 350 fi
 351
 352 if check_define __ANDROID__ ; then
 353   targetos="Android"
 354 elif check_define __linux__ ; then
 355   targetos="Linux"
 356 elif check_define __OpenBSD__ ; then
 357   targetos='OpenBSD'
 358 elif check_define __NetBSD__ ; then
 359   targetos='NetBSD'
 360 elif check_define __sun__ ; then
 361   targetos='SunOS'
 362   CFLAGS="$CFLAGS -D_REENTRANT"
 363 elif check_define _WIN32 ; then
 364   targetos='CYGWIN'
 365 else
 366   targetos=`uname -s`
 367 fi
 368
 369 echo "# Automatically generated by configure - do not modify" > $config_host_mak
 370 printf "# Configured with:" >> $config_host_mak
 371 printf " '%s'" "$0" "$@" >> $config_host_mak
 372 echo >> $config_host_mak
 373 echo "CONFIG_TARGET_OS=$targetos" >> $config_host_mak
 374
 375 if test "$no_shm" = "yes" ; then
 376   output_sym "CONFIG_NO_SHM"
 377 fi
 378
 379 if test "$disable_opt" = "yes" ; then
 380   output_sym "CONFIG_FIO_NO_OPT"
 381 fi
 382
 383 # Some host OSes need non-standard checks for which CPU to use.
 384 # Note that these checks are broken for cross-compilation: if you're
 385 # cross-compiling to one of these OSes then you'll need to specify
 386 # the correct CPU with the --cpu option.
 387 case $targetos in
 388 AIX|OpenBSD|NetBSD)
 389   # Unless explicitly enabled, turn off lex.
 390   # OpenBSD will hit syntax error when enabled.
 391   if test -z "$disable_lex" ; then
 392     disable_lex="yes"
 393   else
 394     force_no_lex_o="yes"
 395   fi
 396   ;;
 397 FreeBSD)
 398   CFLAGS="$CFLAGS -I/usr/local/include"
 399   LDFLAGS="$LDFLAGS -L/usr/local/lib"
 400   ;;
 401 Darwin)
 402   # on Leopard most of the system is 32-bit, so we have to ask the kernel if
 403   # we can run 64-bit userspace code.
 404   # If the user didn't specify a CPU explicitly and the kernel says this is
 405   # 64 bit hw, then assume x86_64. Otherwise fall through to the usual
 406   # detection code.
 407   if test -z "$cpu" && test "$(sysctl -n hw.optional.x86_64)" = "1"; then
 408     cpu="x86_64"
 409   fi
 410   # Avoid configure feature detection of features provided by weak symbols
 411 cat > $TMPC <<EOF
 412 int main(void)
 413 {
 414   return 0;
 415 }
 416 EOF
 417   if compile_prog "" "-Werror=partial-availability" "error on weak symbols"; then
 418     CONFIGURE_CFLAGS="$CONFIGURE_CFLAGS -Werror=partial-availability"
 419   fi
 420   ;;
 421 SunOS)
 422   # `uname -m` returns i86pc even on an x86_64 box, so default based on isainfo
 423   if test -z "$cpu" && test "$(isainfo -k)" = "amd64"; then
 424     cpu="x86_64"
 425   fi
 426   LIBS="-lnsl -lsocket"
 427   ;;
 428 CYGWIN*)
 429   # We still force some options, so keep this message here.
 430   echo "Forcing some known good options on Windows"
 431   if test -z "${CC}${cross_prefix}"; then
 432     if test ! -z "$build_32bit_win" && test "$build_32bit_win" = "yes"; then
 433       cc="i686-w64-mingw32-gcc"
 434     else
 435       cc="x86_64-w64-mingw32-gcc"
 436     fi
 437   fi
 438
 439   target_win_ver=$(echo "$target_win_ver" | tr '[:lower:]' '[:upper:]')
 440   if test -z "$target_win_ver"; then
 441     # Default Windows API target
 442     target_win_ver="7"
 443   fi
 444   if test "$target_win_ver" = "7"; then
 445     output_sym "CONFIG_WINDOWS_7"
 446     CFLAGS="$CFLAGS -D_WIN32_WINNT=0x0601"
 447   else
 448     fatal "Unknown target Windows version"
 449   fi
 450
 451   # We need this to be output_sym'd here because this is Windows specific.
 452   # The regular configure path never sets this config.
 453   output_sym "CONFIG_WINDOWSAIO"
 454   # We now take the regular configuration path without having exit 0 here.
 455   # Flags below are still necessary mostly for MinGW.
 456   build_static="yes"
 457   rusage_thread="yes"
 458   fdatasync="yes"
 459   clock_gettime="yes" # clock_monotonic probe has dependency on this
 460   clock_monotonic="yes"
 461   sched_idle="yes"
 462   pthread_condattr_setclock="no"
 463   pthread_affinity="no"
 464   ;;
 465 esac
 466
 467 # Now we know the target platform we can have another guess at the preferred
 468 # compiler when it wasn't explictly set
 469 if test -z "${CC}${cross_prefix}"; then
 470   if test "$targetos" = "FreeBSD" || test "$targetos" = "Darwin"; then
 471     if has clang; then
 472       cc=clang
 473     fi
 474   fi
 475 fi
 476 if test -z "$cc"; then
 477     echo "configure: failed to find compiler"
 478     exit 1
 479 fi
 480
 481 if test ! -z "$cpu" ; then
 482   # command line argument
 483   :
 484 elif check_define __i386__ ; then
 485   cpu="i386"
 486 elif check_define __x86_64__ ; then
 487   cpu="x86_64"
 488 elif check_define __sparc__ ; then
 489   if check_define __arch64__ ; then
 490     cpu="sparc64"
 491   else
 492     cpu="sparc"
 493   fi
 494 elif check_define _ARCH_PPC ; then
 495   if check_define _ARCH_PPC64 ; then
 496     cpu="ppc64"
 497   else
 498     cpu="ppc"
 499   fi
 500 elif check_define __mips__ ; then
 501   cpu="mips"
 502 elif check_define __ia64__ ; then
 503   cpu="ia64"
 504 elif check_define __s390__ ; then
 505   if check_define __s390x__ ; then
 506     cpu="s390x"
 507   else
 508     cpu="s390"
 509   fi
 510 elif check_define __arm__ ; then
 511   cpu="arm"
 512 elif check_define __aarch64__ ; then
 513   cpu="aarch64"
 514 elif check_define __hppa__ ; then
 515   cpu="hppa"
 516 elif check_define __loongarch64 ; then
 517   cpu="loongarch64"
 518 elif check_define __riscv ; then
 519   if check_val __riscv_xlen 32 ; then
 520     cpu="riscv32"
 521   elif check_val __riscv_xlen 64 ; then
 522     cpu="riscv64"
 523   elif check_val __riscv_xlen 128 ; then
 524     cpu="riscv128"
 525   fi
 526 else
 527   cpu=`uname -m`
 528 fi
 529
 530 # Normalise host CPU name and set ARCH.
 531 case "$cpu" in
 532   ia64|ppc|ppc64|s390|s390x|sparc64|loongarch64|riscv64)
 533     cpu="$cpu"
 534   ;;
 535   i386|i486|i586|i686|i86pc|BePC)
 536     cpu="x86"
 537   ;;
 538   x86_64|amd64)
 539     cpu="x86_64"
 540   ;;
 541   armv*b|armv*l|arm)
 542     cpu="arm"
 543   ;;
 544   aarch64)
 545     cpu="arm64"
 546   ;;
 547   hppa|parisc|parisc64)
 548     cpu="hppa"
 549   ;;
 550   mips*)
 551     cpu="mips"
 552   ;;
 553   sparc|sun4[cdmuv])
 554     cpu="sparc"
 555   ;;
 556   *)
 557   echo "Unknown CPU"
 558   ;;
 559 esac
 560
 561 ##########################################
 562 # check cross compile
 563
 564 if test "$cross_compile" != "yes" ; then
 565   cross_compile="no"
 566 fi
 567 cat > $TMPC <<EOF
 568 int main(void)
 569 {
 570   return 0;
 571 }
 572 EOF
 573 if compile_prog "" "" "cross"; then
 574   $TMPE 2>/dev/null || cross_compile="yes"
 575 else
 576   fatal "compile test failed"
 577 fi
 578
 579 ##########################################
 580 # check endianness
 581 if test "$bigendian" != "yes" ; then
 582   bigendian="no"
 583 fi
 584 if test "$cross_compile" = "no" ; then
 585   cat > $TMPC <<EOF
 586 #include <inttypes.h>
 587 int main(void)
 588 {
 589   volatile uint32_t i=0x01234567;
 590   return (*((uint8_t*)(&i))) == 0x67;
 591 }
 592 EOF
 593   if compile_prog "" "" "endian"; then
 594     $TMPE && bigendian="yes"
 595   fi
 596 else
 597   # If we're cross compiling, try our best to work it out and rely on the
 598   # run-time check to fail if we get it wrong.
 599   cat > $TMPC <<EOF
 600 #include <endian.h>
 601 int main(void)
 602 {
 603 #if __BYTE_ORDER != __BIG_ENDIAN
 604 # error "Unknown endianness"
 605 #endif
 606 }
 607 EOF
 608   compile_prog "" "" "endian" && bigendian="yes"
 609   check_define "__ARMEB__" && bigendian="yes"
 610   check_define "__MIPSEB__" && bigendian="yes"
 611 fi
 612
 613
 614 print_config "Operating system" "$targetos"
 615 print_config "CPU" "$cpu"
 616 print_config "Big endian" "$bigendian"
 617 if test ! -z "$target_win_ver"; then
 618   print_config "Target Windows version" "$target_win_ver"
 619 fi
 620 print_config "Compiler" "$cc"
 621 print_config "Cross compile" "$cross_compile"
 622 echo
 623
 624 ##########################################
 625 # See if we need to build a static build
 626 if test "$build_static" = "yes" ; then
 627   CFLAGS="$CFLAGS -ffunction-sections -fdata-sections"
 628   LDFLAGS="$LDFLAGS -static -Wl,--gc-sections"
 629 else
 630   build_static="no"
 631 fi
 632 print_config "Static build" "$build_static"
 633
 634 ##########################################
 635 # check for C11 atomics support
 636 cat > $TMPC <<EOF
 637 #include <stdatomic.h>
 638 int main(void)
 639 {
 640   _Atomic unsigned v;
 641   atomic_load(&v);
 642   return 0;
 643 }
 644 EOF
 645 if ! compile_prog "" "" "C11 atomics"; then
 646   echo
 647   echo "Your compiler doesn't support C11 atomics. gcc 4.9/clang 3.6 are the"
 648   echo "minimum versions with it - perhaps your compiler is too old?"
 649   fatal "C11 atomics support not found"
 650 fi
 651
 652
 653 ##########################################
 654 # check for wordsize
 655 wordsize="0"
 656 cat > $TMPC <<EOF
 657 #include <limits.h>
 658 #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
 659 int main(void)
 660 {
 661   BUILD_BUG_ON(sizeof(long)*CHAR_BIT != WORDSIZE);
 662   return 0;
 663 }
 664 EOF
 665 if compile_prog "-DWORDSIZE=32" "" "wordsize"; then
 666   wordsize="32"
 667 elif compile_prog "-DWORDSIZE=64" "" "wordsize"; then
 668   wordsize="64"
 669 else
 670   fatal "Unknown wordsize"
 671 fi
 672 print_config "Wordsize" "$wordsize"
 673
 674 ##########################################
 675 # zlib probe
 676 if test "$zlib" != "yes" ; then
 677   zlib="no"
 678 fi
 679 cat > $TMPC <<EOF
 680 #include <zlib.h>
 681 int main(void)
 682 {
 683   z_stream stream;
 684   if (inflateInit(&stream) != Z_OK)
 685     return 1;
 686   return 0;
 687 }
 688 EOF
 689 if compile_prog "" "-lz" "zlib" ; then
 690   zlib=yes
 691   LIBS="-lz $LIBS"
 692 fi
 693 print_config "zlib" "$zlib"
 694
 695 ##########################################
 696 # fcntl(F_FULLFSYNC) support
 697 if test "$fcntl_sync" != "yes" ; then
 698   fcntl_sync="no"
 699 fi
 700 cat > $TMPC << EOF
 701 #include <unistd.h>
 702 #include <fcntl.h>
 703
 704 int main(int argc, char **argv)
 705 {
 706   return fcntl(0, F_FULLFSYNC);
 707 }
 708 EOF
 709 if compile_prog "" "" "fcntl(F_FULLFSYNC)" ; then
 710     fcntl_sync="yes"
 711 fi
 712 print_config "fcntl(F_FULLFSYNC)" "$fcntl_sync"
 713
 714 ##########################################
 715 # linux-aio probe
 716 if test "$libaio" != "yes" ; then
 717   libaio="no"
 718 fi
 719 if test "$esx" != "yes" ; then
 720   cat > $TMPC <<EOF
 721 #include <libaio.h>
 722 #include <stddef.h>
 723 int main(void)
 724 {
 725   io_setup(0, NULL);
 726   return 0;
 727 }
 728 EOF
 729   if compile_prog "" "-laio" "libaio" ; then
 730     libaio=yes
 731   else
 732     if test "$libaio" = "yes" ; then
 733       feature_not_found "linux AIO" "libaio-dev or libaio-devel"
 734     fi
 735     libaio=no
 736   fi
 737
 738   cat > $TMPC <<EOF
 739 #include <libaio.h>
 740 #include <stddef.h>
 741 int main(void)
 742 {
 743   io_prep_preadv2(NULL, 0, NULL, 0, 0, 0);
 744   io_prep_pwritev2(NULL, 0, NULL, 0, 0, 0);
 745   return 0;
 746 }
 747 EOF
 748   if compile_prog "" "" "libaio rw flags" ; then
 749     libaio_rw_flags=yes
 750   else
 751     libaio_rw_flags=no
 752   fi
 753 fi
 754 print_config "Linux AIO support" "$libaio"
 755 print_config "Linux AIO support rw flags" "$libaio_rw_flags"
 756
 757 ##########################################
 758 # posix aio probe
 759 if test "$posix_aio" != "yes" ; then
 760   posix_aio="no"
 761 fi
 762 if test "$posix_aio_lrt" != "yes" ; then
 763   posix_aio_lrt="no"
 764 fi
 765 cat > $TMPC <<EOF
 766 #include <aio.h>
 767 int main(void)
 768 {
 769   struct aiocb cb;
 770   aio_read(&cb);
 771   return 0;
 772 }
 773 EOF
 774 if compile_prog "" "" "posixaio" ; then
 775   posix_aio="yes"
 776 elif compile_prog "" "-lrt" "posixaio -lrt"; then
 777   posix_aio="yes"
 778   posix_aio_lrt="yes"
 779   LIBS="-lrt $LIBS"
 780 fi
 781 print_config "POSIX AIO support" "$posix_aio"
 782 print_config "POSIX AIO support needs -lrt" "$posix_aio_lrt"
 783
 784 ##########################################
 785 # posix aio fsync probe
 786 if test "$posix_aio_fsync" != "yes" ; then
 787   posix_aio_fsync="no"
 788 fi
 789 if test "$posix_aio" = "yes" ; then
 790   cat > $TMPC <<EOF
 791 #include <fcntl.h>
 792 #include <aio.h>
 793 int main(void)
 794 {
 795   struct aiocb cb;
 796   return aio_fsync(O_SYNC, &cb);
 797   return 0;
 798 }
 799 EOF
 800   if compile_prog "" "$LIBS" "posix_aio_fsync" ; then
 801     posix_aio_fsync=yes
 802   fi
 803 fi
 804 print_config "POSIX AIO fsync" "$posix_aio_fsync"
 805
 806 ##########################################
 807 # POSIX pshared attribute probe
 808 if test "$posix_pshared" != "yes" ; then
 809   posix_pshared="no"
 810 fi
 811 cat > $TMPC <<EOF
 812 #include <unistd.h>
 813 int main(void)
 814 {
 815 #if defined(_POSIX_THREAD_PROCESS_SHARED) && ((_POSIX_THREAD_PROCESS_SHARED + 0) > 0)
 816 # if defined(__CYGWIN__)
 817 #  error "_POSIX_THREAD_PROCESS_SHARED is buggy on Cygwin"
 818 # elif defined(__APPLE__)
 819 #  include <AvailabilityMacros.h>
 820 #  include <TargetConditionals.h>
 821 #  if TARGET_OS_MAC && MAC_OS_X_VERSION_MIN_REQUIRED < 1070
 822 #   error "_POSIX_THREAD_PROCESS_SHARED is buggy/unsupported prior to OSX 10.7"
 823 #  endif
 824 # endif
 825 #else
 826 # error "_POSIX_THREAD_PROCESS_SHARED is unsupported"
 827 #endif
 828   return 0;
 829 }
 830 EOF
 831 if compile_prog "" "$LIBS" "posix_pshared" ; then
 832   posix_pshared=yes
 833 fi
 834 print_config "POSIX pshared support" "$posix_pshared"
 835
 836 ##########################################
 837 # POSIX pthread_condattr_setclock() probe
 838 if test "$pthread_condattr_setclock" != "no" ; then
 839   cat > $TMPC <<EOF
 840 #include <pthread.h>
 841 int main(void)
 842 {
 843   pthread_condattr_t condattr;
 844   pthread_condattr_setclock(&condattr, CLOCK_MONOTONIC);
 845   return 0;
 846 }
 847 EOF
 848   if compile_prog "" "$LIBS" "pthread_condattr_setclock" ; then
 849     pthread_condattr_setclock=yes
 850   elif compile_prog "" "$LIBS -lpthread" "pthread_condattr_setclock" ; then
 851     pthread_condattr_setclock=yes
 852     LIBS="$LIBS -lpthread"
 853   fi
 854 fi
 855 print_config "pthread_condattr_setclock()" "$pthread_condattr_setclock"
 856
 857 ##########################################
 858 # pthread_sigmask() probe
 859 if test "$pthread_sigmask" != "yes" ; then
 860   pthread_sigmask="no"
 861 fi
 862 cat > $TMPC <<EOF
 863 #include <stddef.h> /* NULL */
 864 #include <signal.h> /* pthread_sigmask() */
 865 int main(void)
 866 {
 867   return pthread_sigmask(0, NULL, NULL);
 868 }
 869 EOF
 870 if compile_prog "" "$LIBS" "pthread_sigmask" ; then
 871   pthread_sigmask=yes
 872 elif compile_prog "" "$LIBS -lpthread" "pthread_sigmask" ; then
 873   pthread_sigmask=yes
 874   LIBS="$LIBS -lpthread"
 875 fi
 876 print_config "pthread_sigmask()" "$pthread_sigmask"
 877
 878 ##########################################
 879 # pthread_getaffinity_np() probe
 880 if test "$pthread_getaffinity" != "yes" ; then
 881   pthread_getaffinity="no"
 882 fi
 883 cat > $TMPC <<EOF
 884 #include <stddef.h> /* NULL */
 885 #include <signal.h> /* pthread_sigmask() */
 886 #include <pthread.h>
 887 int main(void)
 888 {
 889   cpu_set_t set;
 890   return pthread_getaffinity_np(pthread_self(), sizeof(set), &set);
 891 }
 892 EOF
 893 if compile_prog "" "$LIBS" "pthread_getaffinity" ; then
 894   pthread_getaffinity="yes"
 895 elif compile_prog "" "$LIBS -lpthread" "pthread_getaffinity" ; then
 896   pthread_getaffinity="yes"
 897   LIBS="$LIBS -lpthread"
 898 fi
 899 print_config "pthread_getaffinity_np()" "$pthread_getaffinity"
 900
 901 ##########################################
 902 # solaris aio probe
 903 if test "$solaris_aio" != "yes" ; then
 904   solaris_aio="no"
 905 fi
 906 cat > $TMPC <<EOF
 907 #include <sys/types.h>
 908 #include <sys/asynch.h>
 909 #include <unistd.h>
 910 int main(void)
 911 {
 912   aio_result_t res;
 913   return aioread(0, NULL, 0, 0, SEEK_SET, &res);
 914   return 0;
 915 }
 916 EOF
 917 if compile_prog "" "-laio" "solarisaio" ; then
 918   solaris_aio=yes
 919   LIBS="-laio $LIBS"
 920 fi
 921 print_config "Solaris AIO support" "$solaris_aio"
 922
 923 ##########################################
 924 # __sync_fetch_and_add test
 925 if test "$sfaa" != "yes" ; then
 926   sfaa="no"
 927 fi
 928 cat > $TMPC << EOF
 929 #include <inttypes.h>
 930 static int sfaa(uint64_t *ptr)
 931 {
 932   return __sync_fetch_and_add(ptr, 0);
 933 }
 934
 935 int main(int argc, char **argv)
 936 {
 937   uint64_t val = 42;
 938   sfaa(&val);
 939   return val;
 940 }
 941 EOF
 942 if compile_prog "" "" "__sync_fetch_and_add()" ; then
 943     sfaa="yes"
 944 fi
 945 print_config "__sync_fetch_and_add" "$sfaa"
 946
 947 ##########################################
 948 # __sync_synchronize() test
 949 if test "$sync_sync" != "yes" ; then
 950   sync_sync="no"
 951 fi
 952 cat > $TMPC << EOF
 953 #include <inttypes.h>
 954
 955 int main(int argc, char **argv)
 956 {
 957   __sync_synchronize();
 958   return 0;
 959 }
 960 EOF
 961 if compile_prog "" "" "__sync_synchronize()" ; then
 962     sync_sync="yes"
 963 fi
 964 print_config "__sync_synchronize" "$sync_sync"
 965
 966 ##########################################
 967 # __sync_val_compare_and_swap() test
 968 if test "$cmp_swap" != "yes" ; then
 969   cmp_swap="no"
 970 fi
 971 cat > $TMPC << EOF
 972 #include <inttypes.h>
 973
 974 int main(int argc, char **argv)
 975 {
 976   int x = 0;
 977   return __sync_val_compare_and_swap(&x, 1, 2);
 978 }
 979 EOF
 980 if compile_prog "" "" "__sync_val_compare_and_swap()" ; then
 981     cmp_swap="yes"
 982 fi
 983 print_config "__sync_val_compare_and_swap" "$cmp_swap"
 984
 985 ##########################################
 986 # libverbs probe
 987 if test "$libverbs" != "yes" ; then
 988   libverbs="no"
 989 fi
 990 cat > $TMPC << EOF
 991 #include <infiniband/verbs.h>
 992 int main(int argc, char **argv)
 993 {
 994   struct ibv_pd *pd = ibv_alloc_pd(NULL);
 995   return pd != NULL;
 996 }
 997 EOF
 998 if test "$disable_rdma" != "yes" && compile_prog "" "-libverbs" "libverbs" ; then
 999     libverbs="yes"
1000 fi
1001 print_config "libverbs" "$libverbs"
1002
1003 ##########################################
1004 # rdmacm probe
1005 if test "$rdmacm" != "yes" ; then
1006   rdmacm="no"
1007 fi
1008 cat > $TMPC << EOF
1009 #include <stdio.h>
1010 #include <rdma/rdma_cma.h>
1011 int main(int argc, char **argv)
1012 {
1013   rdma_destroy_qp(NULL);
1014   return 0;
1015 }
1016 EOF
1017 if test "$disable_rdma" != "yes" && compile_prog "" "-lrdmacm" "rdma"; then
1018     rdmacm="yes"
1019 fi
1020 print_config "rdmacm" "$rdmacm"
1021
1022 ##########################################
1023 # librpma probe
1024 # The librpma engines require librpma>=v0.11.0 with rpma_cq_get_wc().
1025 if test "$librpma" != "yes" ; then
1026   librpma="no"
1027 fi
1028 cat > $TMPC << EOF
1029 #include <librpma.h>
1030 int main(void)
1031 {
1032   void *ptr = rpma_cq_get_wc;
1033   (void) ptr; /* unused */
1034   return 0;
1035 }
1036 EOF
1037 if test "$disable_rdma" != "yes" && compile_prog "" "-lrpma" "rpma"; then
1038     librpma="yes"
1039 fi
1040 print_config "librpma" "$librpma"
1041
1042 ##########################################
1043 # libprotobuf-c probe
1044 if test "$libprotobuf_c" != "yes" ; then
1045   libprotobuf_c="no"
1046 fi
1047 cat > $TMPC << EOF
1048 #include <stdio.h>
1049 #include <protobuf-c/protobuf-c.h>
1050 #if !defined(PROTOBUF_C_VERSION_NUMBER)
1051 # error PROTOBUF_C_VERSION_NUMBER is not defined!
1052 #endif
1053 int main(int argc, char **argv)
1054 {
1055   (void)protobuf_c_message_check(NULL);
1056   return 0;
1057 }
1058 EOF
1059 if compile_prog "" "-lprotobuf-c" "protobuf_c"; then
1060     libprotobuf_c="yes"
1061 fi
1062 print_config "libprotobuf_c" "$libprotobuf_c"
1063
1064 ##########################################
1065 # asprintf() and vasprintf() probes
1066 if test "$have_asprintf" != "yes" ; then
1067   have_asprintf="no"
1068 fi
1069 cat > $TMPC << EOF
1070 #include <stdio.h>
1071
1072 int main(int argc, char **argv)
1073 {
1074   char *buf;
1075   return asprintf(&buf, "%s", "str") == 0;
1076 }
1077 EOF
1078 if compile_prog "" "" "have_asprintf"; then
1079     have_asprintf="yes"
1080 fi
1081 print_config "asprintf()" "$have_asprintf"
1082
1083 if test "$have_vasprintf" != "yes" ; then
1084   have_vasprintf="no"
1085 fi
1086 cat > $TMPC << EOF
1087 #include <stdio.h>
1088
1089 int main(int argc, char **argv)
1090 {
1091   va_list ap;
1092   char *buf;
1093   return vasprintf(&buf, "%s", ap) == 0;
1094 }
1095 EOF
1096 if compile_prog "" "" "have_vasprintf"; then
1097     have_vasprintf="yes"
1098 fi
1099 print_config "vasprintf()" "$have_vasprintf"
1100
1101 ##########################################
1102 # Linux fallocate probe
1103 if test "$linux_fallocate" != "yes" ; then
1104   linux_fallocate="no"
1105 fi
1106 cat > $TMPC << EOF
1107 #include <stdio.h>
1108 #include <fcntl.h>
1109 #include <linux/falloc.h>
1110 int main(int argc, char **argv)
1111 {
1112   int r = fallocate(0, FALLOC_FL_KEEP_SIZE, 0, 1024);
1113   return r;
1114 }
1115 EOF
1116 if compile_prog "" "" "linux_fallocate"; then
1117     linux_fallocate="yes"
1118 fi
1119 print_config "Linux fallocate" "$linux_fallocate"
1120
1121 ##########################################
1122 # POSIX fadvise probe
1123 if test "$posix_fadvise" != "yes" ; then
1124   posix_fadvise="no"
1125 fi
1126 cat > $TMPC << EOF
1127 #include <stdio.h>
1128 #include <fcntl.h>
1129 int main(int argc, char **argv)
1130 {
1131   int r = posix_fadvise(0, 0, 0, POSIX_FADV_NORMAL);
1132   return r;
1133 }
1134 EOF
1135 if compile_prog "" "" "posix_fadvise"; then
1136     posix_fadvise="yes"
1137 fi
1138 print_config "POSIX fadvise" "$posix_fadvise"
1139
1140 ##########################################
1141 # POSIX fallocate probe
1142 if test "$posix_fallocate" != "yes" ; then
1143   posix_fallocate="no"
1144 fi
1145 cat > $TMPC << EOF
1146 #include <stdio.h>
1147 #include <fcntl.h>
1148 int main(int argc, char **argv)
1149 {
1150   int r = posix_fallocate(0, 0, 1024);
1151   return r;
1152 }
1153 EOF
1154 if compile_prog "" "" "posix_fallocate"; then
1155     posix_fallocate="yes"
1156 fi
1157 print_config "POSIX fallocate" "$posix_fallocate"
1158
1159 ##########################################
1160 # sched_set/getaffinity 2 or 3 argument test
1161 if test "$linux_2arg_affinity" != "yes" ; then
1162   linux_2arg_affinity="no"
1163 fi
1164 if test "$linux_3arg_affinity" != "yes" ; then
1165   linux_3arg_affinity="no"
1166 fi
1167 cat > $TMPC << EOF
1168 #include <sched.h>
1169 int main(int argc, char **argv)
1170 {
1171   cpu_set_t mask = { };
1172
1173   return sched_setaffinity(0, sizeof(mask), &mask);
1174 }
1175 EOF
1176 if compile_prog "" "" "sched_setaffinity(,,)"; then
1177   linux_3arg_affinity="yes"
1178 else
1179   cat > $TMPC << EOF
1180 #include <sched.h>
1181 int main(int argc, char **argv)
1182 {
1183   cpu_set_t mask = { };
1184
1185   return sched_setaffinity(0, &mask);
1186 }
1187 EOF
1188   if compile_prog "" "" "sched_setaffinity(,)"; then
1189     linux_2arg_affinity="yes"
1190   fi
1191 fi
1192 print_config "sched_setaffinity(3 arg)" "$linux_3arg_affinity"
1193 print_config "sched_setaffinity(2 arg)" "$linux_2arg_affinity"
1194
1195 ##########################################
1196 # clock_gettime probe
1197 if test "$clock_gettime" != "yes" ; then
1198   clock_gettime="no"
1199 fi
1200 cat > $TMPC << EOF
1201 #include <stdio.h>
1202 #include <time.h>
1203 int main(int argc, char **argv)
1204 {
1205   struct timespec ts;
1206
1207   return clock_gettime(0, &ts);
1208 }
1209 EOF
1210 if compile_prog "" "" "clock_gettime"; then
1211     clock_gettime="yes"
1212 elif compile_prog "" "-lrt" "clock_gettime"; then
1213     clock_gettime="yes"
1214     LIBS="-lrt $LIBS"
1215 fi
1216 print_config "clock_gettime" "$clock_gettime"
1217
1218 ##########################################
1219 # CLOCK_MONOTONIC probe
1220 if test "$clock_monotonic" != "yes" ; then
1221   clock_monotonic="no"
1222 fi
1223 if test "$clock_gettime" = "yes" ; then
1224   cat > $TMPC << EOF
1225 #include <stdio.h>
1226 #include <time.h>
1227 int main(int argc, char **argv)
1228 {
1229   struct timespec ts;
1230
1231   return clock_gettime(CLOCK_MONOTONIC, &ts);
1232 }
1233 EOF
1234   if compile_prog "" "$LIBS" "clock monotonic"; then
1235       clock_monotonic="yes"
1236   fi
1237 fi
1238 print_config "CLOCK_MONOTONIC" "$clock_monotonic"
1239
1240 ##########################################
1241 # clockid_t probe
1242 if test "$clockid_t" != "yes" ; then
1243   clockid_t="no"
1244 fi
1245 cat > $TMPC << EOF
1246 #include <time.h>
1247 #include <string.h>
1248 int main(int argc, char **argv)
1249 {
1250   volatile clockid_t cid;
1251   memset((void*)&cid, 0, sizeof(cid));
1252   return 0;
1253 }
1254 EOF
1255 if compile_prog "" "$LIBS" "clockid_t"; then
1256   clockid_t="yes"
1257 fi
1258 print_config "clockid_t" "$clockid_t"
1259
1260 ##########################################
1261 # gettimeofday() probe
1262 if test "$gettimeofday" != "yes" ; then
1263   gettimeofday="no"
1264 fi
1265 cat > $TMPC << EOF
1266 #include <sys/time.h>
1267 #include <stdio.h>
1268 int main(int argc, char **argv)
1269 {
1270   struct timeval tv;
1271   return gettimeofday(&tv, NULL);
1272 }
1273 EOF
1274 if compile_prog "" "" "gettimeofday"; then
1275     gettimeofday="yes"
1276 fi
1277 print_config "gettimeofday" "$gettimeofday"
1278
1279 ##########################################
1280 # fdatasync() probe
1281 if test "$fdatasync" != "yes" ; then
1282   fdatasync="no"
1283 fi
1284 cat > $TMPC << EOF
1285 #include <stdio.h>
1286 #include <unistd.h>
1287 int main(int argc, char **argv)
1288 {
1289   return fdatasync(0);
1290 }
1291 EOF
1292 if compile_prog "" "" "fdatasync"; then
1293   fdatasync="yes"
1294 fi
1295 print_config "fdatasync" "$fdatasync"
1296
1297 ##########################################
1298 # pipe() probe
1299 if test "$pipe" != "yes" ; then
1300   pipe="no"
1301 fi
1302 cat > $TMPC << EOF
1303 #include <unistd.h>
1304 int main(int argc, char **argv)
1305 {
1306   int fd[2];
1307   return pipe(fd);
1308 }
1309 EOF
1310 if compile_prog "" "" "pipe"; then
1311   pipe="yes"
1312 fi
1313 print_config "pipe()" "$pipe"
1314
1315 ##########################################
1316 # pipe2() probe
1317 if test "$pipe2" != "yes" ; then
1318   pipe2="no"
1319 fi
1320 cat > $TMPC << EOF
1321 #include <unistd.h>
1322 int main(int argc, char **argv)
1323 {
1324   int fd[2];
1325   return pipe2(fd, 0);
1326 }
1327 EOF
1328 if compile_prog "" "" "pipe2"; then
1329   pipe2="yes"
1330 fi
1331 print_config "pipe2()" "$pipe2"
1332
1333 ##########################################
1334 # pread() probe
1335 if test "$pread" != "yes" ; then
1336   pread="no"
1337 fi
1338 cat > $TMPC << EOF
1339 #include <unistd.h>
1340 int main(int argc, char **argv)
1341 {
1342   return pread(0, NULL, 0, 0);
1343 }
1344 EOF
1345 if compile_prog "" "" "pread"; then
1346   pread="yes"
1347 fi
1348 print_config "pread()" "$pread"
1349
1350 ##########################################
1351 # sync_file_range() probe
1352 if test "$sync_file_range" != "yes" ; then
1353   sync_file_range="no"
1354 fi
1355 cat > $TMPC << EOF
1356 #include <stdio.h>
1357 #include <unistd.h>
1358 #include <fcntl.h>
1359 #include <linux/fs.h>
1360 int main(int argc, char **argv)
1361 {
1362   unsigned int flags = SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE |
1363                         SYNC_FILE_RANGE_WAIT_AFTER;
1364   return sync_file_range(0, 0, 0, flags);
1365 }
1366 EOF
1367 if compile_prog "" "" "sync_file_range"; then
1368   sync_file_range="yes"
1369 fi
1370 print_config "sync_file_range" "$sync_file_range"
1371
1372 ##########################################
1373 # ASharedMemory_create() probe
1374 if test "$ASharedMemory_create" != "yes" ; then
1375   ASharedMemory_create="no"
1376 fi
1377 cat > $TMPC << EOF
1378 #include <android/sharedmem.h>
1379 int main(int argc, char **argv)
1380 {
1381   return ASharedMemory_create("", 0);
1382 }
1383 EOF
1384 if compile_prog "" "" "ASharedMemory_create"; then
1385   ASharedMemory_create="yes"
1386 fi
1387 print_config "ASharedMemory_create" "$ASharedMemory_create"
1388
1389 ##########################################
1390 # ext4 move extent probe
1391 if test "$ext4_me" != "yes" ; then
1392   ext4_me="no"
1393 fi
1394 cat > $TMPC << EOF
1395 #include <fcntl.h>
1396 #include <sys/ioctl.h>
1397 int main(int argc, char **argv)
1398 {
1399   struct move_extent me;
1400   return ioctl(0, EXT4_IOC_MOVE_EXT, &me);
1401 }
1402 EOF
1403 if compile_prog "" "" "ext4 move extent" ; then
1404   ext4_me="yes"
1405 elif test $targetos = "Linux" ; then
1406   # On Linux, just default to it on and let it error at runtime if we really
1407   # don't have it. None of my updated systems have it defined, but it does
1408   # work. Takes a while to bubble back.
1409   ext4_me="yes"
1410 fi
1411 print_config "EXT4 move extent" "$ext4_me"
1412
1413 ##########################################
1414 # splice probe
1415 if test "$linux_splice" != "yes" ; then
1416   linux_splice="no"
1417 fi
1418 cat > $TMPC << EOF
1419 #include <stdio.h>
1420 #include <fcntl.h>
1421 int main(int argc, char **argv)
1422 {
1423   return splice(0, NULL, 0, NULL, 0, SPLICE_F_NONBLOCK);
1424 }
1425 EOF
1426 if compile_prog "" "" "linux splice"; then
1427   linux_splice="yes"
1428 fi
1429 print_config "Linux splice(2)" "$linux_splice"
1430
1431 ##########################################
1432 # libnuma probe
1433 if test "$libnuma" != "yes" ; then
1434   libnuma="no"
1435 fi
1436 cat > $TMPC << EOF
1437 #include <numa.h>
1438 int main(int argc, char **argv)
1439 {
1440   return numa_available();
1441 }
1442 EOF
1443 if test "$disable_numa" != "yes"  && compile_prog "" "-lnuma" "libnuma"; then
1444   libnuma="yes"
1445   LIBS="-lnuma $LIBS"
1446 fi
1447 print_config "libnuma" "$libnuma"
1448
1449 ##########################################
1450 # libnuma 2.x version API, initialize with "no" only if $libnuma is set to "yes"
1451 if test "$libnuma" = "yes" ; then
1452 libnuma_v2="no"
1453 cat > $TMPC << EOF
1454 #include <numa.h>
1455 int main(int argc, char **argv)
1456 {
1457   struct bitmask *mask = numa_parse_nodestring(NULL);
1458   return mask->size == 0;
1459 }
1460 EOF
1461 if compile_prog "" "" "libnuma api"; then
1462   libnuma_v2="yes"
1463 fi
1464 print_config "libnuma v2" "$libnuma_v2"
1465 fi
1466
1467 ##########################################
1468 # strsep() probe
1469 if test "$strsep" != "yes" ; then
1470   strsep="no"
1471 fi
1472 cat > $TMPC << EOF
1473 #include <string.h>
1474 int main(int argc, char **argv)
1475 {
1476   static char *string = "This is a string";
1477   strsep(&string, "needle");
1478   return 0;
1479 }
1480 EOF
1481 if compile_prog "" "" "strsep"; then
1482   strsep="yes"
1483 fi
1484 print_config "strsep" "$strsep"
1485
1486 ##########################################
1487 # strcasestr() probe
1488 if test "$strcasestr" != "yes" ; then
1489   strcasestr="no"
1490 fi
1491 cat > $TMPC << EOF
1492 #include <string.h>
1493 int main(int argc, char **argv)
1494 {
1495   return strcasestr(argv[0], argv[1]) != NULL;
1496 }
1497 EOF
1498 if compile_prog "" "" "strcasestr"; then
1499   strcasestr="yes"
1500 fi
1501 print_config "strcasestr" "$strcasestr"
1502
1503 ##########################################
1504 # strlcat() probe
1505 if test "$strlcat" != "yes" ; then
1506   strlcat="no"
1507 fi
1508 cat > $TMPC << EOF
1509 #include <string.h>
1510 int main(int argc, char **argv)
1511 {
1512   static char dst[64];
1513   static char *string = "This is a string";
1514   memset(dst, 0, sizeof(dst));
1515   strlcat(dst, string, sizeof(dst));
1516   return 0;
1517 }
1518 EOF
1519 if compile_prog "" "" "strlcat"; then
1520   strlcat="yes"
1521 fi
1522 print_config "strlcat" "$strlcat"
1523
1524 ##########################################
1525 # getopt_long_only() probe
1526 if test "$getopt_long_only" != "yes" ; then
1527   getopt_long_only="no"
1528 fi
1529 cat > $TMPC << EOF
1530 #include <unistd.h>
1531 #include <stdio.h>
1532 #include <getopt.h>
1533 int main(int argc, char **argv)
1534 {
1535   int c = getopt_long_only(argc, argv, "", NULL, NULL);
1536   return c;
1537 }
1538 EOF
1539 if compile_prog "" "" "getopt_long_only"; then
1540   getopt_long_only="yes"
1541 fi
1542 print_config "getopt_long_only()" "$getopt_long_only"
1543
1544 ##########################################
1545 # inet_aton() probe
1546 if test "$inet_aton" != "yes" ; then
1547   inet_aton="no"
1548 fi
1549 cat > $TMPC << EOF
1550 #ifdef _WIN32
1551 #include <winsock2.h>
1552 #else
1553 #include <sys/socket.h>
1554 #include <arpa/inet.h>
1555 #endif
1556 #include <stdio.h>
1557 int main(int argc, char **argv)
1558 {
1559   struct in_addr in;
1560   return inet_aton(NULL, &in);
1561 }
1562 EOF
1563 if compile_prog "" "" "inet_aton"; then
1564   inet_aton="yes"
1565 fi
1566 print_config "inet_aton" "$inet_aton"
1567
1568 ##########################################
1569 # socklen_t probe
1570 if test "$socklen_t" != "yes" ; then
1571   socklen_t="no"
1572 fi
1573 cat > $TMPC << EOF
1574 #ifdef _WIN32
1575 #include <winsock2.h>
1576 #include <ws2tcpip.h>
1577 #else
1578 #include <sys/socket.h>
1579 #endif
1580 int main(int argc, char **argv)
1581 {
1582   socklen_t len = 0;
1583   return len;
1584 }
1585 EOF
1586 if compile_prog "" "" "socklen_t"; then
1587   socklen_t="yes"
1588 fi
1589 print_config "socklen_t" "$socklen_t"
1590
1591 ##########################################
1592 # Whether or not __thread is supported for TLS
1593 if test "$tls_thread" != "yes" ; then
1594   tls_thread="no"
1595 fi
1596 if test "$tls_check" != "no"; then
1597   cat > $TMPC << EOF
1598 #include <stdio.h>
1599 static __thread int ret;
1600 int main(int argc, char **argv)
1601 {
1602   return ret;
1603 }
1604 EOF
1605 if compile_prog "" "" "__thread"; then
1606   tls_thread="yes"
1607 fi
1608 fi
1609 print_config "__thread" "$tls_thread"
1610
1611 ##########################################
1612 # Check if we have required gtk/glib support for gfio
1613 if test "$gfio" != "yes" ; then
1614   gfio="no"
1615 fi
1616 if test "$gfio_check" = "yes" ; then
1617   cat > $TMPC << EOF
1618 #include <glib.h>
1619 #include <cairo.h>
1620 #include <gtk/gtk.h>
1621 int main(void)
1622 {
1623   gdk_threads_enter();
1624   gdk_threads_leave();
1625
1626   return GTK_CHECK_VERSION(2, 18, 0) ? 0 : 1; /* 0 on success */
1627 }
1628 EOF
1629 GTK_CFLAGS=$(${cross_prefix}pkg-config --cflags gtk+-2.0 gthread-2.0)
1630 ORG_LDFLAGS=$LDFLAGS
1631 LDFLAGS=$(echo $LDFLAGS | sed s/"-static"//g)
1632 if test "$?" != "0" ; then
1633   echo "configure: gtk and gthread not found"
1634   exit 1
1635 fi
1636 GTK_LIBS=$(${cross_prefix}pkg-config --libs gtk+-2.0 gthread-2.0)
1637 if test "$?" != "0" ; then
1638   echo "configure: gtk and gthread not found"
1639   exit 1
1640 fi
1641 gfio="yes"
1642 if check_min_lib_version gtk+-2.0 2.18.0 "gfio"; then
1643   if compile_prog "$GTK_CFLAGS" "$GTK_LIBS" "gfio" ; then
1644     GFIO_LIBS="$LIBS $GTK_LIBS"
1645     CFLAGS="$CFLAGS $GTK_CFLAGS"
1646   else
1647     echo "Please install gtk and gdk libraries"
1648     gfio="no"
1649   fi
1650 else
1651   gfio="no"
1652 fi
1653 LDFLAGS=$ORG_LDFLAGS
1654 fi
1655
1656 if test "$gfio_check" = "yes" ; then
1657   print_config "gtk 2.18 or higher" "$gfio"
1658 fi
1659
1660 ##########################################
1661 # Check whether we have getrusage(RUSAGE_THREAD)
1662 if test "$rusage_thread" != "yes" ; then
1663   rusage_thread="no"
1664 fi
1665 cat > $TMPC << EOF
1666 #include <sys/time.h>
1667 #include <sys/resource.h>
1668 int main(int argc, char **argv)
1669 {
1670   struct rusage ru;
1671   getrusage(RUSAGE_THREAD, &ru);
1672   return 0;
1673 }
1674 EOF
1675 if compile_prog "" "" "RUSAGE_THREAD"; then
1676   rusage_thread="yes"
1677 fi
1678 print_config "RUSAGE_THREAD" "$rusage_thread"
1679
1680 ##########################################
1681 # Check whether we have SCHED_IDLE
1682 if test "$sched_idle" != "yes" ; then
1683   sched_idle="no"
1684 fi
1685 cat > $TMPC << EOF
1686 #include <sched.h>
1687 int main(int argc, char **argv)
1688 {
1689   struct sched_param p = { };
1690
1691   return sched_setscheduler(0, SCHED_IDLE, &p);
1692 }
1693 EOF
1694 if compile_prog "" "" "SCHED_IDLE"; then
1695   sched_idle="yes"
1696 fi
1697 print_config "SCHED_IDLE" "$sched_idle"
1698
1699 ##########################################
1700 # Check whether we have TCP_NODELAY
1701 if test "$tcp_nodelay" != "yes" ; then
1702   tcp_nodelay="no"
1703 fi
1704 cat > $TMPC << EOF
1705 #ifdef _WIN32
1706 #include <winsock2.h>
1707 #else
1708 #include <stdio.h>
1709 #include <sys/types.h>
1710 #include <sys/socket.h>
1711 #include <netinet/tcp.h>
1712 #endif
1713 int main(int argc, char **argv)
1714 {
1715   return getsockopt(0, 0, TCP_NODELAY, NULL, NULL);
1716 }
1717 EOF
1718 if compile_prog "" "" "TCP_NODELAY"; then
1719   tcp_nodelay="yes"
1720 elif compile_prog "" "-lws2_32" "TCP_NODELAY"; then
1721   tcp_nodelay="yes"
1722   LIBS="$LIBS -lws2_32"
1723 fi
1724 print_config "TCP_NODELAY" "$tcp_nodelay"
1725
1726 ##########################################
1727 # Check whether we have SO_SNDBUF
1728 if test "$window_size" != "yes" ; then
1729   window_size="no"
1730 fi
1731 cat > $TMPC << EOF
1732 #ifdef _WIN32
1733 #include <winsock2.h>
1734 #else
1735 #include <stdio.h>
1736 #include <sys/types.h>
1737 #include <sys/socket.h>
1738 #include <netinet/tcp.h>
1739 #endif
1740 int main(int argc, char **argv)
1741 {
1742   setsockopt(0, SOL_SOCKET, SO_SNDBUF, NULL, 0);
1743   setsockopt(0, SOL_SOCKET, SO_RCVBUF, NULL, 0);
1744 }
1745 EOF
1746 if compile_prog "" "" "SO_SNDBUF"; then
1747   window_size="yes"
1748 elif compile_prog "" "-lws2_32" "SO_SNDBUF"; then
1749   window_size="yes"
1750   LIBS="$LIBS -lws2_32"
1751 fi
1752 print_config "Net engine window_size" "$window_size"
1753
1754 ##########################################
1755 # Check whether we have TCP_MAXSEG
1756 if test "$mss" != "yes" ; then
1757   mss="no"
1758 fi
1759 cat > $TMPC << EOF
1760 #ifdef _WIN32
1761 #include <winsock2.h>
1762 #else
1763 #include <stdio.h>
1764 #include <sys/types.h>
1765 #include <sys/socket.h>
1766 #include <netinet/tcp.h>
1767 #include <arpa/inet.h>
1768 #include <netinet/in.h>
1769 #endif
1770 int main(int argc, char **argv)
1771 {
1772   return setsockopt(0, IPPROTO_TCP, TCP_MAXSEG, NULL, 0);
1773 }
1774 EOF
1775 if compile_prog "" "" "TCP_MAXSEG"; then
1776   mss="yes"
1777 elif compile_prog "" "-lws2_32" "TCP_MAXSEG"; then
1778   mss="yes"
1779   LIBS="$LIBS -lws2_32"
1780 fi
1781 print_config "TCP_MAXSEG" "$mss"
1782
1783 ##########################################
1784 # Check whether we have RLIMIT_MEMLOCK
1785 if test "$rlimit_memlock" != "yes" ; then
1786   rlimit_memlock="no"
1787 fi
1788 cat > $TMPC << EOF
1789 #include <sys/time.h>
1790 #include <sys/resource.h>
1791 int main(int argc, char **argv)
1792 {
1793   struct rlimit rl;
1794   return getrlimit(RLIMIT_MEMLOCK, &rl);
1795 }
1796 EOF
1797 if compile_prog "" "" "RLIMIT_MEMLOCK"; then
1798   rlimit_memlock="yes"
1799 fi
1800 print_config "RLIMIT_MEMLOCK" "$rlimit_memlock"
1801
1802 ##########################################
1803 # Check whether we have pwritev/preadv
1804 if test "$pwritev" != "yes" ; then
1805   pwritev="no"
1806 fi
1807 cat > $TMPC << EOF
1808 #include <stdio.h>
1809 #include <sys/uio.h>
1810 int main(int argc, char **argv)
1811 {
1812   struct iovec iov[1] = { };
1813
1814   return pwritev(0, iov, 1, 0) + preadv(0, iov, 1, 0);
1815 }
1816 EOF
1817 if compile_prog "" "" "pwritev"; then
1818   pwritev="yes"
1819 fi
1820 print_config "pwritev/preadv" "$pwritev"
1821
1822 ##########################################
1823 # Check whether we have pwritev2/preadv2
1824 if test "$pwritev2" != "yes" ; then
1825   pwritev2="no"
1826 fi
1827 cat > $TMPC << EOF
1828 #include <stdio.h>
1829 #include <sys/uio.h>
1830 int main(int argc, char **argv)
1831 {
1832   struct iovec iov[1] = { };
1833
1834   return pwritev2(0, iov, 1, 0, 0) + preadv2(0, iov, 1, 0, 0);
1835 }
1836 EOF
1837 if compile_prog "" "" "pwritev2"; then
1838   pwritev2="yes"
1839 fi
1840 print_config "pwritev2/preadv2" "$pwritev2"
1841
1842 ##########################################
1843 # Check whether we have the required functions for ipv6
1844 if test "$ipv6" != "yes" ; then
1845   ipv6="no"
1846 fi
1847 cat > $TMPC << EOF
1848 #ifdef _WIN32
1849 #include <winsock2.h>
1850 #include <ws2tcpip.h>
1851 #else
1852 #include <sys/types.h>
1853 #include <sys/socket.h>
1854 #include <netinet/in.h>
1855 #include <netdb.h>
1856 #endif
1857 #include <stdio.h>
1858 int main(int argc, char **argv)
1859 {
1860   struct addrinfo hints = { };
1861   struct in6_addr addr = in6addr_any;
1862   int ret;
1863
1864   ret = getaddrinfo(NULL, NULL, &hints, NULL);
1865   freeaddrinfo(NULL);
1866   printf("%s %d\n", gai_strerror(ret), addr.s6_addr[0]);
1867
1868   return 0;
1869 }
1870 EOF
1871 if compile_prog "" "" "ipv6"; then
1872   ipv6="yes"
1873 fi
1874 print_config "IPv6 helpers" "$ipv6"
1875
1876 ##########################################
1877 # check for http
1878 if test "$http" != "yes" ; then
1879   http="no"
1880 fi
1881 # check for openssl >= 1.1.0, which uses an opaque HMAC_CTX pointer
1882 cat > $TMPC << EOF
1883 #include <curl/curl.h>
1884 #include <openssl/hmac.h>
1885
1886 int main(int argc, char **argv)
1887 {
1888   CURL *curl;
1889   HMAC_CTX *ctx;
1890
1891   curl = curl_easy_init();
1892   curl_easy_cleanup(curl);
1893
1894   ctx = HMAC_CTX_new();
1895   HMAC_CTX_reset(ctx);
1896   HMAC_CTX_free(ctx);
1897   return 0;
1898 }
1899 EOF
1900 # openssl < 1.1.0 uses the HMAC_CTX type directly
1901 cat > $TMPC2 << EOF
1902 #include <curl/curl.h>
1903 #include <openssl/hmac.h>
1904
1905 int main(int argc, char **argv)
1906 {
1907   CURL *curl;
1908   HMAC_CTX ctx;
1909
1910   curl = curl_easy_init();
1911   curl_easy_cleanup(curl);
1912
1913   HMAC_CTX_init(&ctx);
1914   HMAC_CTX_cleanup(&ctx);
1915   return 0;
1916 }
1917 EOF
1918 if test "$disable_http" != "yes"; then
1919   HTTP_LIBS="-lcurl -lssl -lcrypto"
1920   if compile_prog "" "$HTTP_LIBS" "curl-new-ssl"; then
1921     output_sym "CONFIG_HAVE_OPAQUE_HMAC_CTX"
1922     http="yes"
1923   elif mv $TMPC2 $TMPC && compile_prog "" "$HTTP_LIBS" "curl-old-ssl"; then
1924     http="yes"
1925   fi
1926 fi
1927 print_config "http engine" "$http"
1928
1929 ##########################################
1930 # check for rados
1931 if test "$rados" != "yes" ; then
1932   rados="no"
1933 fi
1934 cat > $TMPC << EOF
1935 #include <rados/librados.h>
1936
1937 int main(int argc, char **argv)
1938 {
1939   rados_t cluster;
1940   rados_ioctx_t io_ctx;
1941   const char cluster_name[] = "ceph";
1942   const char user_name[] = "client.admin";
1943   const char pool[] = "rados";
1944
1945   /* The rados_create2 signature required was only introduced in ceph 0.65 */
1946   rados_create2(&cluster, cluster_name, user_name, 0);
1947   rados_ioctx_create(cluster, pool, &io_ctx);
1948
1949   return 0;
1950 }
1951 EOF
1952 if test "$disable_rados" != "yes"  && compile_prog "" "-lrados" "rados"; then
1953   rados="yes"
1954 fi
1955 print_config "Rados engine" "$rados"
1956
1957 ##########################################
1958 # check for rbd
1959 if test "$rbd" != "yes" ; then
1960   rbd="no"
1961 fi
1962 cat > $TMPC << EOF
1963 #include <rbd/librbd.h>
1964
1965 int main(int argc, char **argv)
1966 {
1967   rados_t cluster;
1968   rados_ioctx_t io_ctx;
1969   const char cluster_name[] = "ceph";
1970   const char user_name[] = "client.admin";
1971   const char pool[] = "rbd";
1972   int major, minor, extra;
1973
1974   rbd_version(&major, &minor, &extra);
1975   /* The rados_create2 signature required was only introduced in ceph 0.65 */
1976   rados_create2(&cluster, cluster_name, user_name, 0);
1977   rados_ioctx_create(cluster, pool, &io_ctx);
1978
1979   return 0;
1980 }
1981 EOF
1982 if test "$disable_rbd" != "yes"  && compile_prog "" "-lrbd -lrados" "rbd"; then
1983   rbd="yes"
1984 fi
1985 print_config "Rados Block Device engine" "$rbd"
1986
1987 ##########################################
1988 # check for rbd_poll
1989 if test "$rbd_poll" != "yes" ; then
1990   rbd_poll="no"
1991 fi
1992 if test "$rbd" = "yes"; then
1993 cat > $TMPC << EOF
1994 #include <rbd/librbd.h>
1995 #include <sys/eventfd.h>
1996
1997 int main(int argc, char **argv)
1998 {
1999   rbd_image_t image;
2000   rbd_completion_t comp;
2001
2002   int fd = eventfd(0, EFD_NONBLOCK);
2003   rbd_set_image_notification(image, fd, EVENT_TYPE_EVENTFD);
2004   rbd_poll_io_events(image, comp, 1);
2005
2006   return 0;
2007 }
2008 EOF
2009 if compile_prog "" "-lrbd -lrados" "rbd"; then
2010   rbd_poll="yes"
2011 fi
2012 print_config "rbd_poll" "$rbd_poll"
2013 fi
2014
2015 ##########################################
2016 # check for rbd_invalidate_cache()
2017 if test "$rbd_inval" != "yes" ; then
2018   rbd_inval="no"
2019 fi
2020 if test "$rbd" = "yes"; then
2021 cat > $TMPC << EOF
2022 #include <rbd/librbd.h>
2023
2024 int main(int argc, char **argv)
2025 {
2026   rbd_image_t image;
2027
2028   return rbd_invalidate_cache(image);
2029 }
2030 EOF
2031 if compile_prog "" "-lrbd -lrados" "rbd"; then
2032   rbd_inval="yes"
2033 fi
2034 print_config "rbd_invalidate_cache" "$rbd_inval"
2035 fi
2036
2037 ##########################################
2038 # Check whether we have setvbuf
2039 if test "$setvbuf" != "yes" ; then
2040   setvbuf="no"
2041 fi
2042 cat > $TMPC << EOF
2043 #include <stdio.h>
2044 int main(int argc, char **argv)
2045 {
2046   FILE *f = NULL;
2047   char buf[80];
2048   setvbuf(f, buf, _IOFBF, sizeof(buf));
2049   return 0;
2050 }
2051 EOF
2052 if compile_prog "" "" "setvbuf"; then
2053   setvbuf="yes"
2054 fi
2055 print_config "setvbuf" "$setvbuf"
2056
2057 ##########################################
2058 # check for gfapi
2059 if test "$gfapi" != "yes" ; then
2060   gfapi="no"
2061 fi
2062 cat > $TMPC << EOF
2063 #include <glusterfs/api/glfs.h>
2064
2065 int main(int argc, char **argv)
2066 {
2067   glfs_t *g = glfs_new("foo");
2068
2069   return 0;
2070 }
2071 EOF
2072 if test "$disable_gfapi" != "yes"  && compile_prog "" "-lgfapi -lglusterfs" "gfapi"; then
2073   gfapi="yes"
2074 fi
2075 print_config "Gluster API engine" "$gfapi"
2076
2077 ##########################################
2078 # check for gfapi fadvise support, initialize with "no" only if $gfapi is set to "yes"
2079 if test "$gfapi" = "yes" ; then
2080 gf_fadvise="no"
2081 cat > $TMPC << EOF
2082 #include <glusterfs/api/glfs.h>
2083
2084 int main(int argc, char **argv)
2085 {
2086   struct glfs_fd *fd;
2087   int ret = glfs_fadvise(fd, 0, 0, 1);
2088
2089   return 0;
2090 }
2091 EOF
2092 if compile_prog "" "-lgfapi -lglusterfs" "gfapi"; then
2093   gf_fadvise="yes"
2094 fi
2095 print_config "Gluster API use fadvise" "$gf_fadvise"
2096 fi
2097
2098 ##########################################
2099 # check for newer gfapi
2100 if test "$gfapi" = "yes" ; then
2101 gf_new="no"
2102 cat > $TMPC << EOF
2103 #include <glusterfs/api/glfs.h>
2104
2105 int main(int argc, char **argv)
2106 {
2107   return glfs_fsync(NULL, NULL, NULL) && glfs_ftruncate(NULL, 0, NULL, NULL);
2108 }
2109 EOF
2110 if compile_prog "" "-lgfapi -lglusterfs" "gf new api"; then
2111   gf_new="yes"
2112 fi
2113 print_config "Gluster new API" "$gf_new"
2114 fi
2115
2116 ##########################################
2117 # check for gfapi trim support
2118 if test "$gf_trim" != "yes" ; then
2119   gf_trim="no"
2120 fi
2121 if test "$gfapi" = "yes" ; then
2122 cat > $TMPC << EOF
2123 #include <glusterfs/api/glfs.h>
2124
2125 int main(int argc, char **argv)
2126 {
2127   return glfs_discard_async(NULL, 0, 0);
2128 }
2129 EOF
2130 if compile_prog "" "-lgfapi -lglusterfs" "gf trim"; then
2131   gf_trim="yes"
2132 fi
2133 print_config "Gluster API trim support" "$gf_trim"
2134 fi
2135
2136 ##########################################
2137 # Check if we support stckf on s390
2138 if test "$s390_z196_facilities" != "yes" ; then
2139   s390_z196_facilities="no"
2140 fi
2141 cat > $TMPC << EOF
2142 #define STFLE_BITS_Z196 45 /* various z196 facilities ... */
2143 int main(int argc, char **argv)
2144 {
2145     /* We want just 1 double word to be returned.  */
2146     register unsigned long reg0 asm("0") = 0;
2147     unsigned long stfle_bits;
2148     asm volatile(".machine push"        "\n\t"
2149                  ".machine \"z9-109\""  "\n\t"
2150                  "stfle %0"             "\n\t"
2151                  ".machine pop"         "\n"
2152                  : "=QS" (stfle_bits), "+d" (reg0)
2153                  : : "cc");
2154
2155     if ((stfle_bits & (1UL << (63 - STFLE_BITS_Z196))) != 0)
2156       return 0;
2157     else
2158       return -1;
2159 }
2160 EOF
2161 if compile_prog "" "" "s390_z196_facilities"; then
2162   $TMPE
2163   if [ $? -eq 0 ]; then
2164         s390_z196_facilities="yes"
2165   fi
2166 fi
2167 print_config "s390_z196_facilities" "$s390_z196_facilities"
2168
2169 ##########################################
2170 # Check if we have required environment variables configured for libhdfs
2171 if test "$libhdfs" = "yes" ; then
2172   hdfs_conf_error=0
2173   if test "$JAVA_HOME" = "" ; then
2174     echo "configure: JAVA_HOME should be defined to jdk/jvm path"
2175     hdfs_conf_error=1
2176   fi
2177   if test "$FIO_LIBHDFS_INCLUDE" = "" ; then
2178     echo "configure: FIO_LIBHDFS_INCLUDE should be defined to libhdfs include path"
2179     hdfs_conf_error=1
2180   fi
2181   if test "$FIO_LIBHDFS_LIB" = "" ; then
2182     echo "configure: FIO_LIBHDFS_LIB should be defined to libhdfs library path"
2183     hdfs_conf_error=1
2184   fi
2185   if test "$hdfs_conf_error" = "1" ; then
2186     feature_not_found "libhdfs" ""
2187   fi
2188   FIO_HDFS_CPU=$cpu
2189   if test "$FIO_HDFS_CPU" = "x86_64" ; then
2190     FIO_HDFS_CPU="amd64"
2191   fi
2192 fi
2193 print_config "HDFS engine" "$libhdfs"
2194
2195 ##########################################
2196 # Check whether we have MTD
2197 if test "$mtd" != "yes" ; then
2198   mtd="no"
2199 fi
2200 cat > $TMPC << EOF
2201 #include <string.h>
2202 #include <mtd/mtd-user.h>
2203 #include <sys/ioctl.h>
2204 int main(int argc, char **argv)
2205 {
2206   struct mtd_write_req ops;
2207   struct mtd_info_user info;
2208   memset(&ops, 0, sizeof(ops));
2209   info.type = MTD_MLCNANDFLASH;
2210   return ioctl(0, MEMGETINFO, &info);
2211 }
2212 EOF
2213 if compile_prog "" "" "mtd"; then
2214   mtd="yes"
2215 fi
2216 print_config "MTD" "$mtd"
2217
2218 ##########################################
2219 # Check whether we have libpmem
2220 if test "$libpmem" != "yes" ; then
2221   libpmem="no"
2222 fi
2223 cat > $TMPC << EOF
2224 #include <libpmem.h>
2225 #include <stdlib.h>
2226 int main(int argc, char **argv)
2227 {
2228   return pmem_is_pmem(NULL, 0);
2229 }
2230 EOF
2231 if compile_prog "" "-lpmem" "libpmem"; then
2232   libpmem="yes"
2233 fi
2234 print_config "libpmem" "$libpmem"
2235
2236 ##########################################
2237 # Check whether libpmem's version >= 1.5
2238 if test "$libpmem1_5" != "yes" ; then
2239   libpmem1_5="no"
2240 fi
2241 if test "$libpmem" = "yes"; then
2242   cat > $TMPC << EOF
2243 #include <libpmem.h>
2244 #include <stdlib.h>
2245 int main(int argc, char **argv)
2246 {
2247   pmem_memcpy(NULL, NULL, 0, 0);
2248   return 0;
2249 }
2250 EOF
2251   if compile_prog "" "-lpmem" "libpmem1_5"; then
2252     libpmem1_5="yes"
2253   fi
2254 fi
2255 print_config "libpmem1_5" "$libpmem1_5"
2256
2257 ##########################################
2258 # Check whether we have libpmem2
2259 if test "$libpmem2" != "yes" ; then
2260   libpmem2="no"
2261 fi
2262 cat > $TMPC << EOF
2263 #include <libpmem2.h>
2264 int main(int argc, char **argv)
2265 {
2266   struct pmem2_config *cfg;
2267   pmem2_config_new(&cfg);
2268   pmem2_config_delete(&cfg);
2269   return 0;
2270 }
2271 EOF
2272 if compile_prog "" "-lpmem2" "libpmem2"; then
2273   libpmem2="yes"
2274 fi
2275 print_config "libpmem2" "$libpmem2"
2276
2277 # Choose libpmem-based ioengines
2278 if test "$libpmem" = "yes" && test "$disable_pmem" = "no"; then
2279   devdax="yes"
2280   if test "$libpmem1_5" = "yes"; then
2281     pmem="yes"
2282   fi
2283 fi
2284
2285 ##########################################
2286 # Report whether dev-dax engine is enabled
2287 print_config "PMDK dev-dax engine" "$devdax"
2288
2289 ##########################################
2290 # Report whether libpmem engine is enabled
2291 print_config "PMDK libpmem engine" "$pmem"
2292
2293 ##########################################
2294 # Check whether we support DDN's IME
2295 if test "$libime" != "yes" ; then
2296   libime="no"
2297 fi
2298 cat > $TMPC << EOF
2299 #include <ime_native.h>
2300 int main(int argc, char **argv)
2301 {
2302   int rc;
2303   ime_native_init();
2304   rc = ime_native_finalize();
2305   return 0;
2306 }
2307 EOF
2308 if compile_prog "-I${ime_path}/include" "-L${ime_path}/lib -lim_client" "libime"; then
2309   libime="yes"
2310   CFLAGS="-I${ime_path}/include $CFLAGS"
2311   LDFLAGS="-Wl,-rpath ${ime_path}/lib -L${ime_path}/lib $LDFLAGS"
2312   LIBS="-lim_client $LIBS"
2313 fi
2314 print_config "DDN's Infinite Memory Engine" "$libime"
2315
2316 ##########################################
2317 # Check if we have libiscsi
2318 if test "$libiscsi" != "no" ; then
2319   if check_min_lib_version libiscsi 1.9.0; then
2320     libiscsi="yes"
2321     libiscsi_cflags=$(pkg-config --cflags libiscsi)
2322     libiscsi_libs=$(pkg-config --libs libiscsi)
2323   else
2324     libiscsi="no"
2325   fi
2326 fi
2327 print_config "iscsi engine" "$libiscsi"
2328
2329 ##########################################
2330 # Check if we have libnbd (for NBD support)
2331 if test "$libnbd" != "no" ; then
2332   if check_min_lib_version libnbd 0.9.8; then
2333     libnbd="yes"
2334     libnbd_cflags=$(pkg-config --cflags libnbd)
2335     libnbd_libs=$(pkg-config --libs libnbd)
2336   else
2337     libnbd="no"
2338   fi
2339 fi
2340 print_config "NBD engine" "$libnbd"
2341
2342 ##########################################
2343 # check for dfs (DAOS File System)
2344 if test "$dfs" != "no" ; then
2345   cat > $TMPC << EOF
2346 #include <fcntl.h>
2347 #include <daos.h>
2348 #include <daos_fs.h>
2349
2350 int main(int argc, char **argv)
2351 {
2352   daos_handle_t poh;
2353   daos_handle_t coh;
2354   dfs_t         *dfs;
2355
2356   (void) dfs_mount(poh, coh, O_RDWR, &dfs);
2357
2358   return 0;
2359 }
2360 EOF
2361   if compile_prog "" "-luuid -ldfs -ldaos" "dfs"; then
2362     dfs="yes"
2363   else
2364     dfs="no"
2365   fi
2366 fi
2367 print_config "DAOS File System (dfs) Engine" "$dfs"
2368
2369 ##########################################
2370 # Check if we have libnfs (for userspace nfs support).
2371 if test "$libnfs" != "no" ; then
2372   if $(pkg-config libnfs > /dev/null 2>&1); then
2373     libnfs="yes"
2374     libnfs_cflags=$(pkg-config --cflags libnfs)
2375     libnfs_libs=$(pkg-config --libs libnfs)
2376   else
2377     if test "$libnfs" = "yes" ; then
2378       feature_not_found "libnfs" "libnfs"
2379     fi
2380     libnfs="no"
2381   fi
2382 fi
2383 print_config "NFS engine" "$libnfs"
2384
2385 ##########################################
2386 # Check if we have lex/yacc available
2387 yacc="no"
2388 yacc_is_bison="no"
2389 lex="no"
2390 arith="no"
2391 if test "$disable_lex" = "no" || test -z "$disable_lex" ; then
2392 if test "$targetos" != "SunOS" ; then
2393 if has lex; then
2394   lex="yes"
2395 fi
2396 if has bison; then
2397   yacc="yes"
2398   yacc_is_bison="yes"
2399 elif has yacc; then
2400   yacc="yes"
2401 fi
2402 if test "$yacc" = "yes" && test "$lex" = "yes" ; then
2403   arith="yes"
2404 fi
2405
2406 if test "$arith" = "yes" ; then
2407 cat > $TMPC << EOF
2408 extern int yywrap(void);
2409
2410 int main(int argc, char **argv)
2411 {
2412   yywrap();
2413   return 0;
2414 }
2415 EOF
2416 if compile_prog "" "-lfl" "flex"; then
2417   LIBS="-lfl $LIBS"
2418 elif compile_prog "" "-ll" "lex"; then
2419   LIBS="-ll $LIBS"
2420 else
2421   arith="no"
2422 fi
2423 fi
2424 fi
2425 fi
2426
2427 # Check if lex fails using -o
2428 if test "$arith" = "yes" ; then
2429 if test "$force_no_lex_o" = "yes" ; then
2430   lex_use_o="no"
2431 else
2432 if lex -o lex.yy.c exp/expression-parser.l 2> /dev/null; then
2433   lex_use_o="yes"
2434 else
2435   lex_use_o="no"
2436 fi
2437 fi
2438 fi
2439
2440 print_config "lex/yacc for arithmetic" "$arith"
2441
2442 ##########################################
2443 # Check whether we have setmntent/getmntent
2444 if test "$getmntent" != "yes" ; then
2445   getmntent="no"
2446 fi
2447 cat > $TMPC << EOF
2448 #include <stdio.h>
2449 #include <mntent.h>
2450 int main(int argc, char **argv)
2451 {
2452   FILE *mtab = setmntent(NULL, "r");
2453   struct mntent *mnt = getmntent(mtab);
2454   endmntent(mtab);
2455   return mnt != NULL;
2456 }
2457 EOF
2458 if compile_prog "" "" "getmntent"; then
2459   getmntent="yes"
2460 fi
2461 print_config "getmntent" "$getmntent"
2462
2463 ##########################################
2464 # Check whether we have getmntinfo
2465 # These are originally added for BSDs, but may also work
2466 # on other operating systems with getmntinfo(3).
2467
2468 # getmntinfo(3) for FreeBSD/DragonFlyBSD/OpenBSD.
2469 # Note that NetBSD needs -Werror to catch warning as error.
2470 if test "$getmntinfo" != "yes" ; then
2471   getmntinfo="no"
2472 fi
2473 cat > $TMPC << EOF
2474 #include <stdio.h>
2475 #include <sys/param.h>
2476 #include <sys/mount.h>
2477 int main(int argc, char **argv)
2478 {
2479   struct statfs *st;
2480   return getmntinfo(&st, MNT_NOWAIT);
2481 }
2482 EOF
2483 if compile_prog "-Werror" "" "getmntinfo"; then
2484   getmntinfo="yes"
2485 fi
2486 print_config "getmntinfo" "$getmntinfo"
2487
2488 # getmntinfo(3) for NetBSD.
2489 if test "$getmntinfo_statvfs" != "yes" ; then
2490   getmntinfo_statvfs="no"
2491 fi
2492 cat > $TMPC << EOF
2493 #include <stdio.h>
2494 #include <sys/statvfs.h>
2495 int main(int argc, char **argv)
2496 {
2497   struct statvfs *st;
2498   return getmntinfo(&st, MNT_NOWAIT);
2499 }
2500 EOF
2501 # Skip the test if the one with statfs arg is detected.
2502 if test "$getmntinfo" != "yes" && compile_prog "-Werror" "" "getmntinfo_statvfs"; then
2503   getmntinfo_statvfs="yes"
2504   print_config "getmntinfo_statvfs" "$getmntinfo_statvfs"
2505 fi
2506
2507 ##########################################
2508 # Check whether we have _Static_assert
2509 if test "$static_assert" != "yes" ; then
2510   static_assert="no"
2511 fi
2512 cat > $TMPC << EOF
2513 #include <assert.h>
2514 #include <stdlib.h>
2515 #include <stddef.h>
2516
2517 struct foo {
2518   int a, b;
2519 };
2520
2521 int main(int argc, char **argv)
2522 {
2523   _Static_assert(offsetof(struct foo, a) == 0 , "Check");
2524   return 0 ;
2525 }
2526 EOF
2527 if compile_prog "" "" "static_assert"; then
2528     static_assert="yes"
2529 fi
2530 print_config "Static Assert" "$static_assert"
2531
2532 ##########################################
2533 # Check whether we have bool / stdbool.h
2534 if test "$have_bool" != "yes" ; then
2535   have_bool="no"
2536 fi
2537 cat > $TMPC << EOF
2538 #include <stdbool.h>
2539 int main(int argc, char **argv)
2540 {
2541   bool var = true;
2542   return var != false;
2543 }
2544 EOF
2545 if compile_prog "" "" "bool"; then
2546   have_bool="yes"
2547 fi
2548 print_config "bool" "$have_bool"
2549
2550 ##########################################
2551 # Check whether we have strndup()
2552 strndup="no"
2553 cat > $TMPC << EOF
2554 #include <string.h>
2555 #include <stdlib.h>
2556 int main(int argc, char **argv)
2557 {
2558   char *res = strndup("test string", 8);
2559
2560   free(res);
2561   return 0;
2562 }
2563 EOF
2564 if compile_prog "" "" "strndup"; then
2565   strndup="yes"
2566 fi
2567 print_config "strndup" "$strndup"
2568
2569 ##########################################
2570 # <valgrind/drd.h> probe
2571 # Note: presence of <valgrind/drd.h> implies that <valgrind/valgrind.h> is
2572 # also available but not the other way around.
2573 if test "$valgrind_dev" != "yes" ; then
2574   valgrind_dev="no"
2575 fi
2576 cat > $TMPC << EOF
2577 #include <valgrind/drd.h>
2578 int main(int argc, char **argv)
2579 {
2580   return 0;
2581 }
2582 EOF
2583 if compile_prog "" "" "valgrind_dev"; then
2584   valgrind_dev="yes"
2585 fi
2586 print_config "Valgrind headers" "$valgrind_dev"
2587
2588 if test "$targetos" = "Linux" || test "$targetos" = "Android"; then
2589 ##########################################
2590 # <linux/blkzoned.h> probe
2591 if test "$linux_blkzoned" != "yes" ; then
2592   linux_blkzoned="no"
2593 fi
2594 cat > $TMPC << EOF
2595 #include <linux/blkzoned.h>
2596 int main(int argc, char **argv)
2597 {
2598   return 0;
2599 }
2600 EOF
2601 if compile_prog "" "" "linux_blkzoned"; then
2602   linux_blkzoned="yes"
2603 fi
2604 print_config "Zoned block device support" "$linux_blkzoned"
2605
2606 ##########################################
2607 # Check BLK_ZONE_REP_CAPACITY
2608 cat > $TMPC << EOF
2609 #include <linux/blkzoned.h>
2610 int main(void)
2611 {
2612   return BLK_ZONE_REP_CAPACITY;
2613 }
2614 EOF
2615 if compile_prog "" "" "blkzoned report capacity"; then
2616   output_sym "CONFIG_HAVE_REP_CAPACITY"
2617   rep_capacity="yes"
2618 else
2619   rep_capacity="no"
2620 fi
2621 print_config "Zoned block device capacity" "$rep_capacity"
2622 fi
2623
2624 ##########################################
2625 # libzbc probe
2626 cat > $TMPC << EOF
2627 #include <libzbc/zbc.h>
2628 int main(int argc, char **argv)
2629 {
2630   struct zbc_device *dev = NULL;
2631
2632   return zbc_open("foo=bar", O_RDONLY, &dev);
2633 }
2634 EOF
2635 if test "$libzbc" != "no" ; then
2636   if [ -e /usr/include/libzbc/libzbc ]; then
2637     # SUSE Linux.
2638     CFLAGS="$CFLAGS -I/usr/include/libzbc"
2639   fi
2640   if compile_prog "" "-lzbc" "libzbc"; then
2641     libzbc="yes"
2642     if ! check_min_lib_version libzbc 5; then
2643       libzbc="no"
2644     fi
2645   else
2646     if test "$libzbc" = "yes" ; then
2647       feature_not_found "libzbc" "libzbc or libzbc/zbc.h"
2648     fi
2649     libzbc="no"
2650   fi
2651 fi
2652 print_config "libzbc engine" "$libzbc"
2653
2654 if test "$targetos" = "Linux" ; then
2655 ##########################################
2656 # Check NVME_URING_CMD support
2657 cat > $TMPC << EOF
2658 #include <linux/nvme_ioctl.h>
2659 int main(void)
2660 {
2661   return sizeof(struct nvme_uring_cmd);
2662 }
2663 EOF
2664 if compile_prog "" "" "nvme uring cmd"; then
2665   output_sym "CONFIG_NVME_URING_CMD"
2666   nvme_uring_cmd="yes"
2667 else
2668   nvme_uring_cmd="no"
2669 fi
2670 print_config "NVMe uring command support" "$nvme_uring_cmd"
2671 fi
2672
2673 ##########################################
2674 # Check if we have xnvme
2675 if test "$xnvme" != "no" ; then
2676   if check_min_lib_version xnvme 0.7.0; then
2677     xnvme="yes"
2678     xnvme_cflags=$(pkg-config --cflags xnvme)
2679     xnvme_libs=$(pkg-config --libs xnvme)
2680   else
2681     xnvme="no"
2682   fi
2683 fi
2684 print_config "xnvme engine" "$xnvme"
2685
2686 ##########################################
2687 # Check if we have libblkio
2688 if test "$libblkio" != "no" ; then
2689   if check_min_lib_version blkio 1.0.0; then
2690     libblkio="yes"
2691     libblkio_cflags=$(pkg-config --cflags blkio)
2692     libblkio_libs=$(pkg-config --libs blkio)
2693   else
2694     if test "$libblkio" = "yes" ; then
2695       feature_not_found "libblkio" "libblkio-dev or libblkio-devel"
2696     fi
2697     libblkio="no"
2698   fi
2699 fi
2700 print_config "libblkio engine" "$libblkio"
2701
2702 ##########################################
2703 # check march=armv8-a+crc+crypto
2704 march_armv8_a_crc_crypto="no"
2705 if test "$cpu" = "arm64" ; then
2706   cat > $TMPC <<EOF
2707 #if __linux__
2708 #include <arm_acle.h>
2709 #include <arm_neon.h>
2710 #include <sys/auxv.h>
2711 #endif
2712
2713 int main(void)
2714 {
2715   /* Can we also do a runtime probe? */
2716 #if __linux__
2717   return getauxval(AT_HWCAP);
2718 #elif defined(__APPLE__)
2719   return 0;
2720 #else
2721 # error "Don't know how to do runtime probe for ARM CRC32c"
2722 #endif
2723 }
2724 EOF
2725   if compile_prog "-march=armv8-a+crc+crypto" "" "ARM CRC32c"; then
2726     march_armv8_a_crc_crypto="yes"
2727     CFLAGS="$CFLAGS -march=armv8-a+crc+crypto"
2728     march_set="yes"
2729   fi
2730 fi
2731 print_config "march_armv8_a_crc_crypto" "$march_armv8_a_crc_crypto"
2732
2733 ##########################################
2734 # cuda probe
2735 if test "$cuda" != "no" ; then
2736 cat > $TMPC << EOF
2737 #include <cuda.h>
2738 int main(int argc, char **argv)
2739 {
2740   return cuInit(0);
2741 }
2742 EOF
2743   if compile_prog "" "-lcuda" "cuda"; then
2744     cuda="yes"
2745     LIBS="-lcuda $LIBS"
2746   else
2747     if test "$cuda" = "yes" ; then
2748       feature_not_found "cuda" ""
2749     fi
2750     cuda="no"
2751   fi
2752 fi
2753 print_config "cuda" "$cuda"
2754
2755 ##########################################
2756 # libcufile probe
2757 if test "$libcufile" != "no" ; then
2758 cat > $TMPC << EOF
2759 #include <cufile.h>
2760
2761 int main(int argc, char* argv[]) {
2762    cuFileDriverOpen();
2763    return 0;
2764 }
2765 EOF
2766   if compile_prog "" "-lcuda -lcudart -lcufile -ldl" "libcufile"; then
2767     libcufile="yes"
2768     LIBS="-lcuda -lcudart -lcufile -ldl $LIBS"
2769   else
2770     if test "$libcufile" = "yes" ; then
2771       feature_not_found "libcufile" ""
2772     fi
2773     libcufile="no"
2774   fi
2775 fi
2776 print_config "libcufile" "$libcufile"
2777
2778 ##########################################
2779 # check for cc -march=native
2780 build_native="no"
2781 cat > $TMPC << EOF
2782 int main(int argc, char **argv)
2783 {
2784   return 0;
2785 }
2786 EOF
2787 if test "$disable_native" = "no" && test "$disable_opt" != "yes" && \
2788    compile_prog "-march=native" "" "march=native"; then
2789   build_native="yes"
2790 fi
2791 print_config "Build march=native" "$build_native"
2792
2793 ##########################################
2794 # check for -lcunit
2795 if test "$cunit" != "yes" ; then
2796   cunit="no"
2797 fi
2798 cat > $TMPC << EOF
2799 #include <CUnit/CUnit.h>
2800 #include <CUnit/Basic.h>
2801 int main(void)
2802 {
2803   if (CU_initialize_registry() != CUE_SUCCESS)
2804     return CU_get_error();
2805   CU_basic_set_mode(CU_BRM_VERBOSE);
2806   CU_basic_run_tests();
2807   CU_cleanup_registry();
2808   return CU_get_error();
2809 }
2810 EOF
2811 if compile_prog "" "-lcunit" "CUnit"; then
2812   cunit="yes"
2813 fi
2814 print_config "CUnit" "$cunit"
2815
2816 ##########################################
2817 # check for __kernel_rwf_t
2818 __kernel_rwf_t="no"
2819 cat > $TMPC << EOF
2820 #include <linux/fs.h>
2821 int main(int argc, char **argv)
2822 {
2823   __kernel_rwf_t x;
2824   x = 0;
2825   return x;
2826 }
2827 EOF
2828 if compile_prog "" "" "__kernel_rwf_t"; then
2829   __kernel_rwf_t="yes"
2830 fi
2831 print_config "__kernel_rwf_t" "$__kernel_rwf_t"
2832
2833 ##########################################
2834 # check if gcc has -Wimplicit-fallthrough=2
2835 fallthrough="no"
2836 cat > $TMPC << EOF
2837 int main(int argc, char **argv)
2838 {
2839   return 0;
2840 }
2841 EOF
2842 if compile_prog "-Wimplicit-fallthrough=2" "" "-Wimplicit-fallthrough=2"; then
2843   fallthrough="yes"
2844 fi
2845 print_config "-Wimplicit-fallthrough=2" "$fallthrough"
2846
2847 ##########################################
2848 # check if the compiler has -Wno-stringop-concatenation
2849 no_stringop="no"
2850 cat > $TMPC << EOF
2851 #include <stdio.h>
2852
2853 int main(int argc, char **argv)
2854 {
2855         return printf("%s\n", argv[0]);
2856 }
2857 EOF
2858 if compile_prog "-Wno-stringop-truncation -Werror" "" "no_stringop"; then
2859   no_stringop="yes"
2860 fi
2861 print_config "-Wno-stringop-truncation" "$no_stringop"
2862
2863 ##########################################
2864 # check for MADV_HUGEPAGE support
2865 if test "$thp" != "yes" ; then
2866   thp="no"
2867 fi
2868 if test "$esx" != "yes" ; then
2869   cat > $TMPC <<EOF
2870 #include <sys/mman.h>
2871 int main(void)
2872 {
2873   return madvise(0, 0x1000, MADV_HUGEPAGE);
2874 }
2875 EOF
2876   if compile_prog "" "" "thp" ; then
2877     thp=yes
2878   else
2879     if test "$thp" = "yes" ; then
2880       feature_not_found "Transparent Huge Page" ""
2881     fi
2882     thp=no
2883   fi
2884 fi
2885 print_config "MADV_HUGEPAGE" "$thp"
2886
2887 ##########################################
2888 # check for gettid()
2889 gettid="no"
2890 cat > $TMPC << EOF
2891 #include <unistd.h>
2892 int main(int argc, char **argv)
2893 {
2894   return gettid();
2895 }
2896 EOF
2897 if compile_prog "" "" "gettid"; then
2898   gettid="yes"
2899 fi
2900 print_config "gettid" "$gettid"
2901
2902 ##########################################
2903 # check for statx(2) support by libc
2904 statx="no"
2905 cat > $TMPC << EOF
2906 #include <unistd.h>
2907 #include <sys/stat.h>
2908
2909 int main(int argc, char **argv)
2910 {
2911         struct statx st;
2912         return statx(-1, *argv, 0, 0, &st);
2913 }
2914 EOF
2915 if compile_prog "" "" "statx"; then
2916   statx="yes"
2917 fi
2918 print_config "statx(2)/libc" "$statx"
2919
2920 ##########################################
2921 # check for statx(2) support by kernel
2922 statx_syscall="no"
2923 cat > $TMPC << EOF
2924 #include <unistd.h>
2925 #include <linux/stat.h>
2926 #include <sys/stat.h>
2927 #include <sys/syscall.h>
2928
2929 static int _statx(int dfd, const char *pathname, int flags, unsigned int mask,
2930                   struct statx *buffer)
2931 {
2932         return syscall(__NR_statx, dfd, pathname, flags, mask, buffer);
2933 }
2934
2935 int main(int argc, char **argv)
2936 {
2937         struct statx st;
2938         return _statx(-1, *argv, 0, 0, &st);
2939 }
2940 EOF
2941 if compile_prog "" "" "statx_syscall"; then
2942   statx_syscall="yes"
2943 fi
2944 print_config "statx(2)/syscall" "$statx_syscall"
2945
2946 ##########################################
2947 # check for Windows PDB generation support
2948 if test "pdb" != "no" ; then
2949   cat > $TMPC <<EOF
2950 int main(void)
2951 {
2952   return 0;
2953 }
2954 EOF
2955   if compile_prog "-g -gcodeview" "-fuse-ld=lld -Wl,-pdb,$TMPO" "pdb"; then
2956     pdb=yes
2957   else
2958     if test "$pdb" = "yes"; then
2959       feature_not_found "PDB" "clang and lld"
2960     fi
2961     pdb=no
2962   fi
2963 else
2964   pdb=no
2965 fi
2966 print_config "Windows PDB generation" "$pdb"
2967
2968 ##########################################
2969 # check for timerfd support
2970 timerfd_create="no"
2971 if test "$esx" != "yes" ; then
2972 cat > $TMPC << EOF
2973 #include <sys/time.h>
2974 #include <sys/timerfd.h>
2975
2976 int main(int argc, char **argv)
2977 {
2978         return timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
2979 }
2980 EOF
2981   if compile_prog "" "" "timerfd_create"; then
2982     timerfd_create="yes"
2983   fi
2984 fi
2985 print_config "timerfd_create" "$timerfd_create"
2986
2987 #############################################################################
2988
2989 if test "$wordsize" = "64" ; then
2990   output_sym "CONFIG_64BIT"
2991 elif test "$wordsize" = "32" ; then
2992   output_sym "CONFIG_32BIT"
2993 else
2994   fatal "Unknown wordsize!"
2995 fi
2996 if test "$bigendian" = "yes" ; then
2997   output_sym "CONFIG_BIG_ENDIAN"
2998 else
2999   output_sym "CONFIG_LITTLE_ENDIAN"
3000 fi
3001 if test "$zlib" = "yes" ; then
3002   output_sym "CONFIG_ZLIB"
3003 fi
3004 if test "$libaio" = "yes" ; then
3005   output_sym "CONFIG_LIBAIO"
3006   if test "$libaio_rw_flags" = "yes" ; then
3007     output_sym "CONFIG_LIBAIO_RW_FLAGS"
3008   fi
3009 fi
3010 if test "$posix_aio" = "yes" ; then
3011   output_sym "CONFIG_POSIXAIO"
3012 fi
3013 if test "$posix_aio_fsync" = "yes" ; then
3014   output_sym "CONFIG_POSIXAIO_FSYNC"
3015 fi
3016 if test "$posix_pshared" = "yes" ; then
3017   output_sym "CONFIG_PSHARED"
3018 fi
3019 if test "$pthread_condattr_setclock" = "yes" ; then
3020   output_sym "CONFIG_PTHREAD_CONDATTR_SETCLOCK"
3021 fi
3022 if test "$pthread_sigmask" = "yes" ; then
3023   output_sym "CONFIG_PTHREAD_SIGMASK"
3024 fi
3025 if test "$pthread_getaffinity" = "yes" ; then
3026   output_sym "CONFIG_PTHREAD_GETAFFINITY"
3027 fi
3028 if test "$have_asprintf" = "yes" ; then
3029     output_sym "CONFIG_HAVE_ASPRINTF"
3030 fi
3031 if test "$have_vasprintf" = "yes" ; then
3032     output_sym "CONFIG_HAVE_VASPRINTF"
3033 fi
3034 if test "$linux_fallocate" = "yes" ; then
3035   output_sym "CONFIG_LINUX_FALLOCATE"
3036 fi
3037 if test "$posix_fallocate" = "yes" ; then
3038   output_sym "CONFIG_POSIX_FALLOCATE"
3039 fi
3040 if test "$fdatasync" = "yes" ; then
3041   output_sym "CONFIG_FDATASYNC"
3042 fi
3043 if test "$pipe" = "yes" ; then
3044   output_sym "CONFIG_PIPE"
3045 fi
3046 if test "$pipe2" = "yes" ; then
3047   output_sym "CONFIG_PIPE2"
3048 fi
3049 if test "$pread" = "yes" ; then
3050   output_sym "CONFIG_PREAD"
3051 fi
3052 if test "$sync_file_range" = "yes" ; then
3053   output_sym "CONFIG_SYNC_FILE_RANGE"
3054 fi
3055 if test "$ASharedMemory_create" = "yes" ; then
3056   output_sym "CONFIG_ASHAREDMEMORY_CREATE"
3057 fi
3058 if test "$sfaa" = "yes" ; then
3059   output_sym "CONFIG_SFAA"
3060 fi
3061 if test "$sync_sync" = "yes" ; then
3062   output_sym "CONFIG_SYNC_SYNC"
3063 fi
3064 if test "$cmp_swap" = "yes" ; then
3065   output_sym "CONFIG_CMP_SWAP"
3066 fi
3067 if test "$libverbs" = "yes" -a "$rdmacm" = "yes" ; then
3068   output_sym "CONFIG_RDMA"
3069 fi
3070 # librpma is supported on the 'x86_64' architecture for now
3071 if test "$cpu" = "x86_64" -a "$libverbs" = "yes" -a "$rdmacm" = "yes" \
3072     -a "$librpma" = "yes" \
3073     && test "$libpmem" = "yes" -o "$libpmem2" = "yes" ; then
3074   output_sym "CONFIG_LIBRPMA_APM"
3075 fi
3076 if test "$cpu" = "x86_64" -a "$libverbs" = "yes" -a "$rdmacm" = "yes" \
3077     -a "$librpma" = "yes" -a "$libprotobuf_c" = "yes" \
3078     && test "$libpmem" = "yes" -o "$libpmem2" = "yes" ; then
3079   output_sym "CONFIG_LIBRPMA_GPSPM"
3080 fi
3081 if test "$clock_gettime" = "yes" ; then
3082   output_sym "CONFIG_CLOCK_GETTIME"
3083 fi
3084 if test "$clock_monotonic" = "yes" ; then
3085   output_sym "CONFIG_CLOCK_MONOTONIC"
3086 fi
3087 if test "$clockid_t" = "yes"; then
3088   output_sym "CONFIG_CLOCKID_T"
3089 fi
3090 if test "$gettimeofday" = "yes" ; then
3091   output_sym "CONFIG_GETTIMEOFDAY"
3092 fi
3093 if test "$posix_fadvise" = "yes" ; then
3094   output_sym "CONFIG_POSIX_FADVISE"
3095 fi
3096 if test "$linux_3arg_affinity" = "yes" ; then
3097   output_sym "CONFIG_3ARG_AFFINITY"
3098 elif test "$linux_2arg_affinity" = "yes" ; then
3099   output_sym "CONFIG_2ARG_AFFINITY"
3100 fi
3101 if test "$strsep" = "yes" ; then
3102   output_sym "CONFIG_STRSEP"
3103 fi
3104 if test "$strcasestr" = "yes" ; then
3105   output_sym "CONFIG_STRCASESTR"
3106 fi
3107 if test "$strlcat" = "yes" ; then
3108   output_sym "CONFIG_STRLCAT"
3109 fi
3110 if test "$getopt_long_only" = "yes" ; then
3111   output_sym "CONFIG_GETOPT_LONG_ONLY"
3112 fi
3113 if test "$inet_aton" = "yes" ; then
3114   output_sym "CONFIG_INET_ATON"
3115 fi
3116 if test "$socklen_t" = "yes" ; then
3117   output_sym "CONFIG_SOCKLEN_T"
3118 fi
3119 if test "$ext4_me" = "yes" ; then
3120   output_sym "CONFIG_LINUX_EXT4_MOVE_EXTENT"
3121 fi
3122 if test "$linux_splice" = "yes" ; then
3123   output_sym "CONFIG_LINUX_SPLICE"
3124 fi
3125 if test "$libnuma_v2" = "yes" ; then
3126   output_sym "CONFIG_LIBNUMA"
3127 fi
3128 if test "$solaris_aio" = "yes" ; then
3129   output_sym "CONFIG_SOLARISAIO"
3130 fi
3131 if test "$tls_thread" = "yes" ; then
3132   output_sym "CONFIG_TLS_THREAD"
3133 fi
3134 if test "$rusage_thread" = "yes" ; then
3135   output_sym "CONFIG_RUSAGE_THREAD"
3136 fi
3137 if test "$gfio" = "yes" ; then
3138   output_sym "CONFIG_GFIO"
3139 fi
3140 if test "$esx" = "yes" ; then
3141   output_sym "CONFIG_ESX"
3142   output_sym "CONFIG_NO_SHM"
3143 fi
3144 if test "$sched_idle" = "yes" ; then
3145   output_sym "CONFIG_SCHED_IDLE"
3146 fi
3147 if test "$tcp_nodelay" = "yes" ; then
3148   output_sym "CONFIG_TCP_NODELAY"
3149 fi
3150 if test "$window_size" = "yes" ; then
3151   output_sym "CONFIG_NET_WINDOWSIZE"
3152 fi
3153 if test "$mss" = "yes" ; then
3154   output_sym "CONFIG_NET_MSS"
3155 fi
3156 if test "$rlimit_memlock" = "yes" ; then
3157   output_sym "CONFIG_RLIMIT_MEMLOCK"
3158 fi
3159 if test "$pwritev" = "yes" ; then
3160   output_sym "CONFIG_PWRITEV"
3161 fi
3162 if test "$pwritev2" = "yes" ; then
3163   output_sym "CONFIG_PWRITEV2"
3164 fi
3165 if test "$ipv6" = "yes" ; then
3166   output_sym "CONFIG_IPV6"
3167 fi
3168 if test "$http" = "yes" ; then
3169   output_sym "CONFIG_HTTP"
3170 fi
3171 if test "$rados" = "yes" ; then
3172   output_sym "CONFIG_RADOS"
3173 fi
3174 if test "$rbd" = "yes" ; then
3175   output_sym "CONFIG_RBD"
3176 fi
3177 if test "$rbd_poll" = "yes" ; then
3178   output_sym "CONFIG_RBD_POLL"
3179 fi
3180 if test "$rbd_inval" = "yes" ; then
3181   output_sym "CONFIG_RBD_INVAL"
3182 fi
3183 if test "$setvbuf" = "yes" ; then
3184   output_sym "CONFIG_SETVBUF"
3185 fi
3186 if test "$s390_z196_facilities" = "yes" ; then
3187   output_sym "CONFIG_S390_Z196_FACILITIES"
3188   CFLAGS="$CFLAGS -march=z9-109"
3189   march_set="yes"
3190 fi
3191 if test "$gfapi" = "yes" ; then
3192   output_sym "CONFIG_GFAPI"
3193 fi
3194 if test "$gf_fadvise" = "yes" ; then
3195   output_sym "CONFIG_GF_FADVISE"
3196 fi
3197 if test "$gf_trim" = "yes" ; then
3198   output_sym "CONFIG_GF_TRIM"
3199 fi
3200 if test "$gf_new" = "yes" ; then
3201   output_sym "CONFIG_GF_NEW_API"
3202 fi
3203 if test "$libhdfs" = "yes" ; then
3204   output_sym "CONFIG_LIBHDFS"
3205   echo "FIO_HDFS_CPU=$FIO_HDFS_CPU" >> $config_host_mak
3206   echo "JAVA_HOME=$JAVA_HOME" >> $config_host_mak
3207   echo "FIO_LIBHDFS_INCLUDE=$FIO_LIBHDFS_INCLUDE" >> $config_host_mak
3208   echo "FIO_LIBHDFS_LIB=$FIO_LIBHDFS_LIB" >> $config_host_mak
3209 fi
3210 if test "$mtd" = "yes" ; then
3211   output_sym "CONFIG_MTD"
3212 fi
3213 if test "$devdax" = "yes" ; then
3214   output_sym "CONFIG_LINUX_DEVDAX"
3215 fi
3216 if test "$pmem" = "yes" ; then
3217   output_sym "CONFIG_LIBPMEM"
3218 fi
3219 if test "$libpmem2" = "yes" ; then
3220   output_sym "CONFIG_LIBPMEM2_INSTALLED"
3221 fi
3222 if test "$libime" = "yes" ; then
3223   output_sym "CONFIG_IME"
3224 fi
3225 if test "$arith" = "yes" ; then
3226   output_sym "CONFIG_ARITHMETIC"
3227   if test "$yacc_is_bison" = "yes" ; then
3228     echo "YACC=bison -y" >> $config_host_mak
3229   else
3230     echo "YACC=yacc" >> $config_host_mak
3231   fi
3232   if test "$lex_use_o" = "yes" ; then
3233     echo "CONFIG_LEX_USE_O=y" >> $config_host_mak
3234   fi
3235 fi
3236 if test "$getmntent" = "yes" ; then
3237   output_sym "CONFIG_GETMNTENT"
3238 fi
3239 if test "$getmntinfo" = "yes" ; then
3240   output_sym "CONFIG_GETMNTINFO"
3241 fi
3242 if test "$getmntinfo_statvfs" = "yes" ; then
3243   output_sym "CONFIG_GETMNTINFO_STATVFS"
3244 fi
3245 if test "$static_assert" = "yes" ; then
3246   output_sym "CONFIG_STATIC_ASSERT"
3247 fi
3248 if test "$have_bool" = "yes" ; then
3249   output_sym "CONFIG_HAVE_BOOL"
3250 fi
3251 if test "$strndup" = "yes" ; then
3252   output_sym "CONFIG_HAVE_STRNDUP"
3253 fi
3254 if test "$disable_opt" = "yes" ; then
3255   output_sym "CONFIG_DISABLE_OPTIMIZATIONS"
3256 fi
3257 if test "$valgrind_dev" = "yes"; then
3258   output_sym "CONFIG_VALGRIND_DEV"
3259 fi
3260 if test "$linux_blkzoned" = "yes" ; then
3261   output_sym "CONFIG_HAS_BLKZONED"
3262 fi
3263 if test "$libzbc" = "yes" ; then
3264   output_sym "CONFIG_LIBZBC"
3265 fi
3266 if test "$zlib" = "no" ; then
3267   echo "Consider installing zlib1g-dev (zlib-devel) as some fio features depend on it."
3268   if test "$build_static" = "yes"; then
3269     echo "Note that some distros have separate packages for static libraries."
3270   fi
3271 fi
3272 if test "$march_armv8_a_crc_crypto" = "yes" ; then
3273   output_sym "ARCH_HAVE_CRC_CRYPTO"
3274 fi
3275 if test "$cuda" = "yes" ; then
3276   output_sym "CONFIG_CUDA"
3277 fi
3278 if test "$libcufile" = "yes" ; then
3279   output_sym "CONFIG_LIBCUFILE"
3280 fi
3281 if test "$dfs" = "yes" ; then
3282   output_sym "CONFIG_DFS"
3283 fi
3284 if test "$march_set" = "no" && test "$build_native" = "yes" ; then
3285   output_sym "CONFIG_BUILD_NATIVE"
3286 fi
3287 if test "$cunit" = "yes" ; then
3288   output_sym "CONFIG_HAVE_CUNIT"
3289 fi
3290 if test "$__kernel_rwf_t" = "yes"; then
3291   output_sym "CONFIG_HAVE_KERNEL_RWF_T"
3292 fi
3293 if test "$gettid" = "yes"; then
3294   output_sym "CONFIG_HAVE_GETTID"
3295 fi
3296 if test "$statx" = "yes"; then
3297   output_sym "CONFIG_HAVE_STATX"
3298 fi
3299 if test "$statx_syscall" = "yes"; then
3300   output_sym "CONFIG_HAVE_STATX_SYSCALL"
3301 fi
3302 if test "$timerfd_create" = "yes"; then
3303   output_sym "CONFIG_HAVE_TIMERFD_CREATE"
3304 fi
3305 if test "$fallthrough" = "yes"; then
3306   CFLAGS="$CFLAGS -Wimplicit-fallthrough"
3307 fi
3308 if test "$no_stringop" = "yes"; then
3309   output_sym "CONFIG_HAVE_NO_STRINGOP"
3310 fi
3311 if test "$thp" = "yes" ; then
3312   output_sym "CONFIG_HAVE_THP"
3313 fi
3314 if test "$libiscsi" = "yes" ; then
3315   output_sym "CONFIG_LIBISCSI"
3316   echo "CONFIG_LIBISCSI=m" >> $config_host_mak
3317   echo "LIBISCSI_CFLAGS=$libiscsi_cflags" >> $config_host_mak
3318   echo "LIBISCSI_LIBS=$libiscsi_libs" >> $config_host_mak
3319 fi
3320 if test "$libnbd" = "yes" ; then
3321   output_sym "CONFIG_LIBNBD"
3322   echo "CONFIG_LIBNBD=m" >> $config_host_mak
3323   echo "LIBNBD_CFLAGS=$libnbd_cflags" >> $config_host_mak
3324   echo "LIBNBD_LIBS=$libnbd_libs" >> $config_host_mak
3325 fi
3326 if test "$libnfs" = "yes" ; then
3327   output_sym "CONFIG_LIBNFS"
3328   echo "LIBNFS_CFLAGS=$libnfs_cflags" >> $config_host_mak
3329   echo "LIBNFS_LIBS=$libnfs_libs" >> $config_host_mak
3330 fi
3331 if test "$xnvme" = "yes" ; then
3332   output_sym "CONFIG_LIBXNVME"
3333   echo "LIBXNVME_CFLAGS=$xnvme_cflags" >> $config_host_mak
3334   echo "LIBXNVME_LIBS=$xnvme_libs" >> $config_host_mak
3335 fi
3336 if test "$libblkio" = "yes" ; then
3337   output_sym "CONFIG_LIBBLKIO"
3338   echo "LIBBLKIO_CFLAGS=$libblkio_cflags" >> $config_host_mak
3339   echo "LIBBLKIO_LIBS=$libblkio_libs" >> $config_host_mak
3340 fi
3341 if test "$dynamic_engines" = "yes" ; then
3342   output_sym "CONFIG_DYNAMIC_ENGINES"
3343 fi
3344 if test "$pdb" = yes; then
3345   output_sym "CONFIG_PDB"
3346 fi
3347 if test "$fcntl_sync" = "yes" ; then
3348   output_sym "CONFIG_FCNTL_SYNC"
3349 fi
3350 if test "$asan" = "yes"; then
3351   CFLAGS="$CFLAGS -fsanitize=address"
3352   LDFLAGS="$LDFLAGS -fsanitize=address"
3353 fi
3354 print_config "Lib-based ioengines dynamic" "$dynamic_engines"
3355 cat > $TMPC << EOF
3356 int main(int argc, char **argv)
3357 {
3358   return 0;
3359 }
3360 EOF
3361 if test "$disable_tcmalloc" != "yes"; then
3362   if compile_prog "" "-ltcmalloc" "tcmalloc"; then
3363     tcmalloc="yes"
3364     LIBS="-ltcmalloc $LIBS"
3365   elif compile_prog "" "-l:libtcmalloc_minimal.so.4" "tcmalloc_minimal4"; then
3366     tcmalloc="yes"
3367     LIBS="-l:libtcmalloc_minimal.so.4 $LIBS"
3368   else
3369     tcmalloc="no"
3370   fi
3371 fi
3372 print_config "TCMalloc support" "$tcmalloc"
3373 if ! num "$seed_buckets"; then
3374   seed_buckets=4
3375 elif test "$seed_buckets" -lt 2; then
3376   seed_buckets=2
3377 elif test "$seed_buckets" -gt 16; then
3378   seed_buckets=16
3379 fi
3380 echo "#define CONFIG_SEED_BUCKETS $seed_buckets" >> $config_host_h
3381 print_config "seed_buckets" "$seed_buckets"
3382
3383 echo "LIBS+=$LIBS" >> $config_host_mak
3384 echo "GFIO_LIBS+=$GFIO_LIBS" >> $config_host_mak
3385 echo "CFLAGS+=$CFLAGS" >> $config_host_mak
3386 echo "LDFLAGS+=$LDFLAGS" >> $config_host_mak
3387 echo "CC=$cc" >> $config_host_mak
3388 echo "BUILD_CFLAGS=$BUILD_CFLAGS $CFLAGS" >> $config_host_mak
3389 echo "INSTALL_PREFIX=$prefix" >> $config_host_mak
3390
3391 if [ `dirname $0` != "." -a ! -e Makefile ]; then
3392     cat > Makefile <<EOF
3393 SRCDIR:=`dirname $0`
3394 include \$(SRCDIR)/Makefile
3395 EOF
3396 fi