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