config/spl-build.m4

   1 ###############################################################################
   2 # Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
   3 # Copyright (C) 2007 The Regents of the University of California.
   4 # Written by Brian Behlendorf <behlendorf1@llnl.gov>.
   5 ###############################################################################
   6 # SPL_AC_CONFIG_KERNEL: Default SPL kernel configuration.
   7 ###############################################################################
   8
   9 AC_DEFUN([SPL_AC_CONFIG_KERNEL], [
  10         SPL_AC_KERNEL
  11
  12         if test "${LINUX_OBJ}" != "${LINUX}"; then
  13                 KERNELMAKE_PARAMS="$KERNELMAKE_PARAMS O=$LINUX_OBJ"
  14         fi
  15         AC_SUBST(KERNELMAKE_PARAMS)
  16
  17         KERNELCPPFLAGS="$KERNELCPPFLAGS -Wstrict-prototypes"
  18         AC_SUBST(KERNELCPPFLAGS)
  19
  20         SPL_AC_TEST_MODULE
  21         SPL_AC_ATOMIC_SPINLOCK
  22         SPL_AC_SHRINKER_CALLBACK
  23         SPL_AC_CTL_NAME
  24         SPL_AC_CONFIG_TRIM_UNUSED_KSYMS
  25         SPL_AC_PDE_DATA
  26         SPL_AC_SET_FS_PWD_WITH_CONST
  27         SPL_AC_2ARGS_VFS_FSYNC
  28         SPL_AC_INODE_TRUNCATE_RANGE
  29         SPL_AC_FS_STRUCT_SPINLOCK
  30         SPL_AC_KUIDGID_T
  31         SPL_AC_KERNEL_FALLOCATE
  32         SPL_AC_CONFIG_ZLIB_INFLATE
  33         SPL_AC_CONFIG_ZLIB_DEFLATE
  34         SPL_AC_2ARGS_ZLIB_DEFLATE_WORKSPACESIZE
  35         SPL_AC_SHRINK_CONTROL_STRUCT
  36         SPL_AC_RWSEM_SPINLOCK_IS_RAW
  37         SPL_AC_RWSEM_ACTIVITY
  38         SPL_AC_RWSEM_ATOMIC_LONG_COUNT
  39         SPL_AC_SCHED_RT_HEADER
  40         SPL_AC_SCHED_SIGNAL_HEADER
  41         SPL_AC_4ARGS_VFS_GETATTR
  42         SPL_AC_3ARGS_VFS_GETATTR
  43         SPL_AC_2ARGS_VFS_GETATTR
  44         SPL_AC_USLEEP_RANGE
  45         SPL_AC_KMEM_CACHE_ALLOCFLAGS
  46         SPL_AC_KERNEL_INODE_TIMES
  47         SPL_AC_WAIT_ON_BIT
  48         SPL_AC_INODE_LOCK
  49         SPL_AC_GROUP_INFO_GID
  50         SPL_AC_KMEM_CACHE_CREATE_USERCOPY
  51         SPL_AC_WAIT_QUEUE_ENTRY_T
  52         SPL_AC_WAIT_QUEUE_HEAD_ENTRY
  53         SPL_AC_IO_SCHEDULE_TIMEOUT
  54         SPL_AC_KERNEL_WRITE
  55         SPL_AC_KERNEL_READ
  56         SPL_AC_KERNEL_TIMER_FUNCTION_TIMER_LIST
  57 ])
  58
  59 AC_DEFUN([SPL_AC_MODULE_SYMVERS], [
  60         modpost=$LINUX/scripts/Makefile.modpost
  61         AC_MSG_CHECKING([kernel file name for module symbols])
  62         if test "x$enable_linux_builtin" != xyes -a -f "$modpost"; then
  63                 if grep -q Modules.symvers $modpost; then
  64                         LINUX_SYMBOLS=Modules.symvers
  65                 else
  66                         LINUX_SYMBOLS=Module.symvers
  67                 fi
  68
  69                 if ! test -f "$LINUX_OBJ/$LINUX_SYMBOLS"; then
  70                         AC_MSG_ERROR([
  71         *** Please make sure the kernel devel package for your distribution
  72         *** is installed.  If you are building with a custom kernel, make sure the
  73         *** kernel is configured, built, and the '--with-linux=PATH' configure
  74         *** option refers to the location of the kernel source.])
  75                 fi
  76         else
  77                 LINUX_SYMBOLS=NONE
  78         fi
  79         AC_MSG_RESULT($LINUX_SYMBOLS)
  80         AC_SUBST(LINUX_SYMBOLS)
  81 ])
  82
  83 AC_DEFUN([SPL_AC_KERNEL], [
  84         AC_ARG_WITH([linux],
  85                 AS_HELP_STRING([--with-linux=PATH],
  86                 [Path to kernel source]),
  87                 [kernelsrc="$withval"])
  88
  89         AC_ARG_WITH([linux-obj],
  90                 AS_HELP_STRING([--with-linux-obj=PATH],
  91                 [Path to kernel build objects]),
  92                 [kernelbuild="$withval"])
  93
  94         AC_MSG_CHECKING([kernel source directory])
  95         if test -z "$kernelsrc"; then
  96                 if test -e "/lib/modules/$(uname -r)/source"; then
  97                         headersdir="/lib/modules/$(uname -r)/source"
  98                         sourcelink=$(readlink -f "$headersdir")
  99                 elif test -e "/lib/modules/$(uname -r)/build"; then
 100                         headersdir="/lib/modules/$(uname -r)/build"
 101                         sourcelink=$(readlink -f "$headersdir")
 102                 else
 103                         sourcelink=$(ls -1d /usr/src/kernels/* \
 104                                      /usr/src/linux-* \
 105                                      2>/dev/null | grep -v obj | tail -1)
 106                 fi
 107
 108                 if test -n "$sourcelink" && test -e ${sourcelink}; then
 109                         kernelsrc=`readlink -f ${sourcelink}`
 110                 else
 111                         kernelsrc="[Not found]"
 112                 fi
 113         else
 114                 if test "$kernelsrc" = "NONE"; then
 115                         kernsrcver=NONE
 116                 fi
 117                 withlinux=yes
 118         fi
 119
 120         AC_MSG_RESULT([$kernelsrc])
 121         if test ! -d "$kernelsrc"; then
 122                 AC_MSG_ERROR([
 123         *** Please make sure the kernel devel package for your distribution
 124         *** is installed and then try again.  If that fails, you can specify the
 125         *** location of the kernel source with the '--with-linux=PATH' option.])
 126         fi
 127
 128         AC_MSG_CHECKING([kernel build directory])
 129         if test -z "$kernelbuild"; then
 130                 if test x$withlinux != xyes -a -e "/lib/modules/$(uname -r)/build"; then
 131                         kernelbuild=`readlink -f /lib/modules/$(uname -r)/build`
 132                 elif test -d ${kernelsrc}-obj/${target_cpu}/${target_cpu}; then
 133                         kernelbuild=${kernelsrc}-obj/${target_cpu}/${target_cpu}
 134                 elif test -d ${kernelsrc}-obj/${target_cpu}/default; then
 135                         kernelbuild=${kernelsrc}-obj/${target_cpu}/default
 136                 elif test -d `dirname ${kernelsrc}`/build-${target_cpu}; then
 137                         kernelbuild=`dirname ${kernelsrc}`/build-${target_cpu}
 138                 else
 139                         kernelbuild=${kernelsrc}
 140                 fi
 141         fi
 142         AC_MSG_RESULT([$kernelbuild])
 143
 144         AC_MSG_CHECKING([kernel source version])
 145         utsrelease1=$kernelbuild/include/linux/version.h
 146         utsrelease2=$kernelbuild/include/linux/utsrelease.h
 147         utsrelease3=$kernelbuild/include/generated/utsrelease.h
 148         if test -r $utsrelease1 && fgrep -q UTS_RELEASE $utsrelease1; then
 149                 utsrelease=linux/version.h
 150         elif test -r $utsrelease2 && fgrep -q UTS_RELEASE $utsrelease2; then
 151                 utsrelease=linux/utsrelease.h
 152         elif test -r $utsrelease3 && fgrep -q UTS_RELEASE $utsrelease3; then
 153                 utsrelease=generated/utsrelease.h
 154         fi
 155
 156         if test "$utsrelease"; then
 157                 kernsrcver=`(echo "#include <$utsrelease>";
 158                              echo "kernsrcver=UTS_RELEASE") |
 159                              cpp -I $kernelbuild/include |
 160                              grep "^kernsrcver=" | cut -d \" -f 2`
 161
 162                 if test -z "$kernsrcver"; then
 163                         AC_MSG_RESULT([Not found])
 164                         AC_MSG_ERROR([*** Cannot determine kernel version.])
 165                 fi
 166         else
 167                 AC_MSG_RESULT([Not found])
 168                 if test "x$enable_linux_builtin" != xyes; then
 169                         AC_MSG_ERROR([*** Cannot find UTS_RELEASE definition.])
 170                 else
 171                         AC_MSG_ERROR([
 172         *** Cannot find UTS_RELEASE definition.
 173         *** Please run 'make prepare' inside the kernel source tree.])
 174                 fi
 175         fi
 176
 177         AC_MSG_RESULT([$kernsrcver])
 178
 179         LINUX=${kernelsrc}
 180         LINUX_OBJ=${kernelbuild}
 181         LINUX_VERSION=${kernsrcver}
 182
 183         AC_SUBST(LINUX)
 184         AC_SUBST(LINUX_OBJ)
 185         AC_SUBST(LINUX_VERSION)
 186
 187         SPL_AC_MODULE_SYMVERS
 188 ])
 189
 190 dnl #
 191 dnl # Default SPL user configuration
 192 dnl #
 193 AC_DEFUN([SPL_AC_CONFIG_USER], [])
 194
 195 dnl #
 196 dnl # Check for rpm+rpmbuild to build RPM packages.  If these tools
 197 dnl # are missing, it is non-fatal, but you will not be able to build
 198 dnl # RPM packages and will be warned if you try too.
 199 dnl #
 200 dnl # By default, the generic spec file will be used because it requires
 201 dnl # minimal dependencies.  Distribution specific spec files can be
 202 dnl # placed under the 'rpm/<distribution>' directory and enabled using
 203 dnl # the --with-spec=<distribution> configure option.
 204 dnl #
 205 AC_DEFUN([SPL_AC_RPM], [
 206         RPM=rpm
 207         RPMBUILD=rpmbuild
 208
 209         AC_MSG_CHECKING([whether $RPM is available])
 210         AS_IF([tmp=$($RPM --version 2>/dev/null)], [
 211                 RPM_VERSION=$(echo $tmp | $AWK '/RPM/ { print $[3] }')
 212                 HAVE_RPM=yes
 213                 AC_MSG_RESULT([$HAVE_RPM ($RPM_VERSION)])
 214         ],[
 215                 HAVE_RPM=no
 216                 AC_MSG_RESULT([$HAVE_RPM])
 217         ])
 218
 219         AC_MSG_CHECKING([whether $RPMBUILD is available])
 220         AS_IF([tmp=$($RPMBUILD --version 2>/dev/null)], [
 221                 RPMBUILD_VERSION=$(echo $tmp | $AWK '/RPM/ { print $[3] }')
 222                 HAVE_RPMBUILD=yes
 223                 AC_MSG_RESULT([$HAVE_RPMBUILD ($RPMBUILD_VERSION)])
 224         ],[
 225                 HAVE_RPMBUILD=no
 226                 AC_MSG_RESULT([$HAVE_RPMBUILD])
 227         ])
 228
 229         RPM_DEFINE_COMMON='--define "$(DEBUG_SPL) 1"'
 230         RPM_DEFINE_COMMON+=' --define "$(DEBUG_KMEM) 1"'
 231         RPM_DEFINE_COMMON+=' --define "$(DEBUG_KMEM_TRACKING) 1"'
 232         RPM_DEFINE_UTIL=
 233         RPM_DEFINE_KMOD='--define "kernels $(LINUX_VERSION)"'
 234         RPM_DEFINE_KMOD+=' --define "_wrong_version_format_terminate_build 0"'
 235         RPM_DEFINE_DKMS=
 236
 237         SRPM_DEFINE_COMMON='--define "build_src_rpm 1"'
 238         SRPM_DEFINE_UTIL=
 239         SRPM_DEFINE_KMOD=
 240         SRPM_DEFINE_DKMS=
 241
 242         RPM_SPEC_DIR="rpm/generic"
 243         AC_ARG_WITH([spec],
 244                 AS_HELP_STRING([--with-spec=SPEC],
 245                 [Spec files 'generic|redhat']),
 246                 [RPM_SPEC_DIR="rpm/$withval"])
 247
 248         AC_MSG_CHECKING([whether spec files are available])
 249         AC_MSG_RESULT([yes ($RPM_SPEC_DIR/*.spec.in)])
 250
 251         AC_SUBST(HAVE_RPM)
 252         AC_SUBST(RPM)
 253         AC_SUBST(RPM_VERSION)
 254
 255         AC_SUBST(HAVE_RPMBUILD)
 256         AC_SUBST(RPMBUILD)
 257         AC_SUBST(RPMBUILD_VERSION)
 258
 259         AC_SUBST(RPM_SPEC_DIR)
 260         AC_SUBST(RPM_DEFINE_UTIL)
 261         AC_SUBST(RPM_DEFINE_KMOD)
 262         AC_SUBST(RPM_DEFINE_DKMS)
 263         AC_SUBST(RPM_DEFINE_COMMON)
 264         AC_SUBST(SRPM_DEFINE_UTIL)
 265         AC_SUBST(SRPM_DEFINE_KMOD)
 266         AC_SUBST(SRPM_DEFINE_DKMS)
 267         AC_SUBST(SRPM_DEFINE_COMMON)
 268 ])
 269
 270 dnl #
 271 dnl # Check for dpkg+dpkg-buildpackage to build DEB packages.  If these
 272 dnl # tools are missing it is non-fatal but you will not be able to build
 273 dnl # DEB packages and will be warned if you try too.
 274 dnl #
 275 AC_DEFUN([SPL_AC_DPKG], [
 276         DPKG=dpkg
 277         DPKGBUILD=dpkg-buildpackage
 278
 279         AC_MSG_CHECKING([whether $DPKG is available])
 280         AS_IF([tmp=$($DPKG --version 2>/dev/null)], [
 281                 DPKG_VERSION=$(echo $tmp | $AWK '/Debian/ { print $[7] }')
 282                 HAVE_DPKG=yes
 283                 AC_MSG_RESULT([$HAVE_DPKG ($DPKG_VERSION)])
 284         ],[
 285                 HAVE_DPKG=no
 286                 AC_MSG_RESULT([$HAVE_DPKG])
 287         ])
 288
 289         AC_MSG_CHECKING([whether $DPKGBUILD is available])
 290         AS_IF([tmp=$($DPKGBUILD --version 2>/dev/null)], [
 291                 DPKGBUILD_VERSION=$(echo $tmp | \
 292                     $AWK '/Debian/ { print $[4] }' | cut -f-4 -d'.')
 293                 HAVE_DPKGBUILD=yes
 294                 AC_MSG_RESULT([$HAVE_DPKGBUILD ($DPKGBUILD_VERSION)])
 295         ],[
 296                 HAVE_DPKGBUILD=no
 297                 AC_MSG_RESULT([$HAVE_DPKGBUILD])
 298         ])
 299
 300         AC_SUBST(HAVE_DPKG)
 301         AC_SUBST(DPKG)
 302         AC_SUBST(DPKG_VERSION)
 303
 304         AC_SUBST(HAVE_DPKGBUILD)
 305         AC_SUBST(DPKGBUILD)
 306         AC_SUBST(DPKGBUILD_VERSION)
 307 ])
 308
 309 dnl #
 310 dnl # Until native packaging for various different packing systems
 311 dnl # can be added the least we can do is attempt to use alien to
 312 dnl # convert the RPM packages to the needed package type.  This is
 313 dnl # a hack but so far it has worked reasonable well.
 314 dnl #
 315 AC_DEFUN([SPL_AC_ALIEN], [
 316         ALIEN=alien
 317
 318         AC_MSG_CHECKING([whether $ALIEN is available])
 319         AS_IF([tmp=$($ALIEN --version 2>/dev/null)], [
 320                 ALIEN_VERSION=$(echo $tmp | $AWK '{ print $[3] }')
 321                 HAVE_ALIEN=yes
 322                 AC_MSG_RESULT([$HAVE_ALIEN ($ALIEN_VERSION)])
 323         ],[
 324                 HAVE_ALIEN=no
 325                 AC_MSG_RESULT([$HAVE_ALIEN])
 326         ])
 327
 328         AC_SUBST(HAVE_ALIEN)
 329         AC_SUBST(ALIEN)
 330         AC_SUBST(ALIEN_VERSION)
 331 ])
 332
 333 dnl #
 334 dnl # Using the VENDOR tag from config.guess set the default
 335 dnl # package type for 'make pkg': (rpm | deb | tgz)
 336 dnl #
 337 AC_DEFUN([SPL_AC_DEFAULT_PACKAGE], [
 338         AC_MSG_CHECKING([linux distribution])
 339         if test -f /etc/toss-release ; then
 340                 VENDOR=toss ;
 341         elif test -f /etc/fedora-release ; then
 342                 VENDOR=fedora ;
 343         elif test -f /etc/redhat-release ; then
 344                 VENDOR=redhat ;
 345         elif test -f /etc/gentoo-release ; then
 346                 VENDOR=gentoo ;
 347         elif test -f /etc/arch-release ; then
 348                 VENDOR=arch ;
 349         elif test -f /etc/SuSE-release ; then
 350                 VENDOR=sles ;
 351         elif test -f /etc/slackware-version ; then
 352                 VENDOR=slackware ;
 353         elif test -f /etc/lunar.release ; then
 354                 VENDOR=lunar ;
 355         elif test -f /etc/lsb-release ; then
 356                 VENDOR=ubuntu ;
 357         elif test -f /etc/debian_version ; then
 358                 VENDOR=debian ;
 359         else
 360                 VENDOR= ;
 361         fi
 362         AC_MSG_RESULT([$VENDOR])
 363         AC_SUBST(VENDOR)
 364
 365         AC_MSG_CHECKING([default package type])
 366         case "$VENDOR" in
 367                 toss)       DEFAULT_PACKAGE=rpm  ;;
 368                 redhat)     DEFAULT_PACKAGE=rpm  ;;
 369                 fedora)     DEFAULT_PACKAGE=rpm  ;;
 370                 gentoo)     DEFAULT_PACKAGE=tgz  ;;
 371                 arch)       DEFAULT_PACKAGE=tgz  ;;
 372                 sles)       DEFAULT_PACKAGE=rpm  ;;
 373                 slackware)  DEFAULT_PACKAGE=tgz  ;;
 374                 lunar)      DEFAULT_PACKAGE=tgz  ;;
 375                 ubuntu)     DEFAULT_PACKAGE=deb  ;;
 376                 debian)     DEFAULT_PACKAGE=deb  ;;
 377                 *)          DEFAULT_PACKAGE=rpm  ;;
 378         esac
 379
 380         AC_MSG_RESULT([$DEFAULT_PACKAGE])
 381         AC_SUBST(DEFAULT_PACKAGE)
 382 ])
 383
 384 dnl #
 385 dnl # Default SPL user configuration
 386 dnl #
 387 AC_DEFUN([SPL_AC_PACKAGE], [
 388         SPL_AC_DEFAULT_PACKAGE
 389         SPL_AC_RPM
 390         SPL_AC_DPKG
 391         SPL_AC_ALIEN
 392 ])
 393
 394 AC_DEFUN([SPL_AC_LICENSE], [
 395         AC_MSG_CHECKING([spl author])
 396         AC_MSG_RESULT([$SPL_META_AUTHOR])
 397
 398         AC_MSG_CHECKING([spl license])
 399         AC_MSG_RESULT([$SPL_META_LICENSE])
 400 ])
 401
 402 AC_DEFUN([SPL_AC_CONFIG], [
 403         SPL_CONFIG=all
 404         AC_ARG_WITH([config],
 405                 AS_HELP_STRING([--with-config=CONFIG],
 406                 [Config file 'kernel|user|all|srpm']),
 407                 [SPL_CONFIG="$withval"])
 408         AC_ARG_ENABLE([linux-builtin],
 409                 [AC_HELP_STRING([--enable-linux-builtin],
 410                 [Configure for builtin in-tree kernel modules @<:@default=no@:>@])],
 411                 [],
 412                 [enable_linux_builtin=no])
 413
 414         AC_MSG_CHECKING([spl config])
 415         AC_MSG_RESULT([$SPL_CONFIG]);
 416         AC_SUBST(SPL_CONFIG)
 417
 418         case "$SPL_CONFIG" in
 419                 kernel) SPL_AC_CONFIG_KERNEL ;;
 420                 user)   SPL_AC_CONFIG_USER   ;;
 421                 all)    SPL_AC_CONFIG_KERNEL
 422                         SPL_AC_CONFIG_USER   ;;
 423                 srpm)                        ;;
 424                 *)
 425                 AC_MSG_RESULT([Error!])
 426                 AC_MSG_ERROR([Bad value "$SPL_CONFIG" for --with-config,
 427                              user kernel|user|all|srpm]) ;;
 428         esac
 429
 430         AM_CONDITIONAL([CONFIG_USER],
 431                        [test "$SPL_CONFIG" = user -o "$SPL_CONFIG" = all])
 432         AM_CONDITIONAL([CONFIG_KERNEL],
 433                        [test "$SPL_CONFIG" = kernel -o "$SPL_CONFIG" = all] &&
 434                        [test "x$enable_linux_builtin" != xyes ])
 435 ])
 436
 437 dnl #
 438 dnl # Enable if the SPL should be compiled with internal debugging enabled.
 439 dnl # By default this support is disabled.
 440 dnl #
 441 AC_DEFUN([SPL_AC_DEBUG], [
 442         AC_MSG_CHECKING([whether debugging is enabled])
 443         AC_ARG_ENABLE([debug],
 444                 [AS_HELP_STRING([--enable-debug],
 445                 [Enable generic debug support @<:@default=no@:>@])],
 446                 [],
 447                 [enable_debug=no])
 448
 449         AS_IF([test "x$enable_debug" = xyes],
 450         [
 451                 KERNELCPPFLAGS="${KERNELCPPFLAGS} -DDEBUG -Werror"
 452                 DEBUG_CFLAGS="-DDEBUG -Werror"
 453                 DEBUG_SPL="_with_debug"
 454         ], [
 455                 KERNELCPPFLAGS="${KERNELCPPFLAGS} -DNDEBUG"
 456                 DEBUG_CFLAGS="-DNDEBUG"
 457                 DEBUG_SPL="_without_debug"
 458         ])
 459
 460         AC_SUBST(DEBUG_CFLAGS)
 461         AC_SUBST(DEBUG_SPL)
 462         AC_MSG_RESULT([$enable_debug])
 463 ])
 464
 465 dnl #
 466 dnl # Enabled by default it provides a minimal level of memory tracking.
 467 dnl # A total count of bytes allocated is kept for each alloc and free.
 468 dnl # Then at module unload time a report to the console will be printed
 469 dnl # if memory was leaked.
 470 dnl #
 471 AC_DEFUN([SPL_AC_DEBUG_KMEM], [
 472         AC_ARG_ENABLE([debug-kmem],
 473                 [AS_HELP_STRING([--enable-debug-kmem],
 474                 [Enable basic kmem accounting @<:@default=no@:>@])],
 475                 [],
 476                 [enable_debug_kmem=no])
 477
 478         AS_IF([test "x$enable_debug_kmem" = xyes],
 479         [
 480                 KERNELCPPFLAGS="${KERNELCPPFLAGS} -DDEBUG_KMEM"
 481                 DEBUG_KMEM="_with_debug_kmem"
 482                 AC_DEFINE([DEBUG_KMEM], [1],
 483                 [Define to 1 to enable basic kmem accounting])
 484         ], [
 485                 DEBUG_KMEM="_without_debug_kmem"
 486         ])
 487
 488         AC_SUBST(DEBUG_KMEM)
 489         AC_MSG_CHECKING([whether basic kmem accounting is enabled])
 490         AC_MSG_RESULT([$enable_debug_kmem])
 491 ])
 492
 493 dnl #
 494 dnl # Disabled by default it provides detailed memory tracking.  This
 495 dnl # feature also requires --enable-debug-kmem to be set.  When enabled
 496 dnl # not only will total bytes be tracked but also the location of every
 497 dnl # alloc and free.  When the SPL module is unloaded a list of all leaked
 498 dnl # addresses and where they were allocated will be dumped to the console.
 499 dnl # Enabling this feature has a significant impact on performance but it
 500 dnl # makes finding memory leaks pretty straight forward.
 501 dnl #
 502 AC_DEFUN([SPL_AC_DEBUG_KMEM_TRACKING], [
 503         AC_ARG_ENABLE([debug-kmem-tracking],
 504                 [AS_HELP_STRING([--enable-debug-kmem-tracking],
 505                 [Enable detailed kmem tracking  @<:@default=no@:>@])],
 506                 [],
 507                 [enable_debug_kmem_tracking=no])
 508
 509         AS_IF([test "x$enable_debug_kmem_tracking" = xyes],
 510         [
 511                 KERNELCPPFLAGS="${KERNELCPPFLAGS} -DDEBUG_KMEM_TRACKING"
 512                 DEBUG_KMEM_TRACKING="_with_debug_kmem_tracking"
 513                 AC_DEFINE([DEBUG_KMEM_TRACKING], [1],
 514                 [Define to 1 to enable detailed kmem tracking])
 515         ], [
 516                 DEBUG_KMEM_TRACKING="_without_debug_kmem_tracking"
 517         ])
 518
 519         AC_SUBST(DEBUG_KMEM_TRACKING)
 520         AC_MSG_CHECKING([whether detailed kmem tracking is enabled])
 521         AC_MSG_RESULT([$enable_debug_kmem_tracking])
 522 ])
 523
 524 dnl #
 525 dnl # SPL_LINUX_CONFTEST
 526 dnl #
 527 AC_DEFUN([SPL_LINUX_CONFTEST], [
 528 cat confdefs.h - <<_ACEOF >conftest.c
 529 $1
 530 _ACEOF
 531 ])
 532
 533 dnl #
 534 dnl # SPL_LANG_PROGRAM(C)([PROLOGUE], [BODY])
 535 dnl #
 536 m4_define([SPL_LANG_PROGRAM], [
 537 $1
 538 int
 539 main (void)
 540 {
 541 dnl Do *not* indent the following line: there may be CPP directives.
 542 dnl Don't move the `;' right after for the same reason.
 543 $2
 544   ;
 545   return 0;
 546 }
 547 ])
 548
 549 dnl #
 550 dnl # SPL_LINUX_COMPILE_IFELSE / like AC_COMPILE_IFELSE
 551 dnl #
 552 AC_DEFUN([SPL_LINUX_COMPILE_IFELSE], [
 553         m4_ifvaln([$1], [SPL_LINUX_CONFTEST([$1])])
 554         rm -Rf build && mkdir -p build && touch build/conftest.mod.c
 555         echo "obj-m := conftest.o" >build/Makefile
 556         modpost_flag=''
 557         test "x$enable_linux_builtin" = xyes && modpost_flag='modpost=true' # fake modpost stage
 558         AS_IF(
 559                 [AC_TRY_COMMAND(cp conftest.c build && make [$2] -C $LINUX_OBJ EXTRA_CFLAGS="-Werror-implicit-function-declaration $EXTRA_KCFLAGS" $ARCH_UM M=$PWD/build $modpost_flag) >/dev/null && AC_TRY_COMMAND([$3])],
 560                 [$4],
 561                 [_AC_MSG_LOG_CONFTEST m4_ifvaln([$5],[$5])]
 562         )
 563         rm -Rf build
 564 ])
 565
 566 dnl #
 567 dnl # SPL_LINUX_TRY_COMPILE like AC_TRY_COMPILE
 568 dnl #
 569 AC_DEFUN([SPL_LINUX_TRY_COMPILE],
 570         [SPL_LINUX_COMPILE_IFELSE(
 571         [AC_LANG_SOURCE([SPL_LANG_PROGRAM([[$1]], [[$2]])])],
 572         [modules],
 573         [test -s build/conftest.o],
 574         [$3], [$4])
 575 ])
 576
 577 dnl #
 578 dnl # SPL_CHECK_SYMBOL_EXPORT
 579 dnl # check symbol exported or not
 580 dnl #
 581 AC_DEFUN([SPL_CHECK_SYMBOL_EXPORT], [
 582         grep -q -E '[[[:space:]]]$1[[[:space:]]]' \
 583                 $LINUX_OBJ/Module*.symvers 2>/dev/null
 584         rc=$?
 585         if test $rc -ne 0; then
 586                 export=0
 587                 for file in $2; do
 588                         grep -q -E "EXPORT_SYMBOL.*($1)" \
 589                                 "$LINUX_OBJ/$file" 2>/dev/null
 590                         rc=$?
 591                         if test $rc -eq 0; then
 592                                 export=1
 593                                 break;
 594                         fi
 595                 done
 596                 if test $export -eq 0; then :
 597                         $4
 598                 else :
 599                         $3
 600                 fi
 601         else :
 602                 $3
 603         fi
 604 ])
 605
 606 dnl #
 607 dnl # SPL_LINUX_TRY_COMPILE_SYMBOL
 608 dnl # like SPL_LINUX_TRY_COMPILE, except SPL_CHECK_SYMBOL_EXPORT
 609 dnl # is called if not compiling for builtin
 610 dnl #
 611 AC_DEFUN([SPL_LINUX_TRY_COMPILE_SYMBOL], [
 612         SPL_LINUX_TRY_COMPILE([$1], [$2], [rc=0], [rc=1])
 613         if test $rc -ne 0; then :
 614                 $6
 615         else
 616                 if test "x$enable_linux_builtin" != xyes; then
 617                         SPL_CHECK_SYMBOL_EXPORT([$3], [$4], [rc=0], [rc=1])
 618                 fi
 619                 if test $rc -ne 0; then :
 620                         $6
 621                 else :
 622                         $5
 623                 fi
 624         fi
 625 ])
 626
 627 dnl #
 628 dnl # SPL_CHECK_SYMBOL_HEADER
 629 dnl # check if a symbol prototype is defined in listed headers.
 630 dnl #
 631 AC_DEFUN([SPL_CHECK_SYMBOL_HEADER], [
 632         AC_MSG_CHECKING([whether symbol $1 exists in header])
 633         header=0
 634         for file in $3; do
 635                 grep -q "$2" "$LINUX/$file" 2>/dev/null
 636                 rc=$?
 637                 if test $rc -eq 0; then
 638                         header=1
 639                         break;
 640                 fi
 641         done
 642         if test $header -eq 0; then
 643                 AC_MSG_RESULT([no])
 644                 $5
 645         else
 646                 AC_MSG_RESULT([yes])
 647                 $4
 648         fi
 649 ])
 650
 651 dnl #
 652 dnl # SPL_CHECK_HEADER
 653 dnl # check whether header exists and define HAVE_$2_HEADER
 654 dnl #
 655 AC_DEFUN([SPL_CHECK_HEADER],
 656         [AC_MSG_CHECKING([whether header $1 exists])
 657         SPL_LINUX_TRY_COMPILE([
 658                 #include <$1>
 659         ],[
 660                 return 0;
 661         ],[
 662                 AC_DEFINE(HAVE_$2_HEADER, 1, [$1 exists])
 663                 AC_MSG_RESULT(yes)
 664                 $3
 665         ],[
 666                 AC_MSG_RESULT(no)
 667                 $4
 668         ])
 669 ])
 670
 671 dnl #
 672 dnl # Basic toolchain sanity check.  Verify that kernel modules can
 673 dnl # be built and which symbols can be used.
 674 dnl #
 675 AC_DEFUN([SPL_AC_TEST_MODULE],
 676         [AC_MSG_CHECKING([whether modules can be built])
 677         SPL_LINUX_TRY_COMPILE([],[],[
 678                 AC_MSG_RESULT([yes])
 679         ],[
 680                 AC_MSG_RESULT([no])
 681                 if test "x$enable_linux_builtin" != xyes; then
 682                         AC_MSG_ERROR([*** Unable to build an empty module.])
 683                 else
 684                         AC_MSG_ERROR([
 685         *** Unable to build an empty module.
 686         *** Please run 'make scripts' inside the kernel source tree.])
 687                 fi
 688         ])
 689
 690         AS_IF([test "x$cross_compiling" != xyes], [
 691                 AC_RUN_IFELSE([
 692                         AC_LANG_PROGRAM([
 693                                 #include "$LINUX/include/linux/license.h"
 694                         ], [
 695                                 return !license_is_gpl_compatible(
 696                                     "$SPL_META_LICENSE");
 697                         ])
 698                 ], [
 699                         AC_DEFINE([SPL_IS_GPL_COMPATIBLE], [1],
 700                             [Define to 1 if GPL-only symbols can be used])
 701                 ], [
 702                 ])
 703         ])
 704 ])
 705
 706 dnl #
 707 dnl # Use the atomic implemenation based on global spinlocks.  This
 708 dnl # should only be needed by 32-bit kernels which do not provide
 709 dnl # the atomic64_* API.  It may be optionally enabled as a fallback
 710 dnl # if problems are observed with the direct mapping to the native
 711 dnl # Linux atomic operations.  You may not disable atomic spinlocks
 712 dnl # if you kernel does not an atomic64_* API.
 713 dnl #
 714 AC_DEFUN([SPL_AC_ATOMIC_SPINLOCK], [
 715         AC_ARG_ENABLE([atomic-spinlocks],
 716                 [AS_HELP_STRING([--enable-atomic-spinlocks],
 717                 [Atomic types use spinlocks @<:@default=check@:>@])],
 718                 [],
 719                 [enable_atomic_spinlocks=check])
 720
 721         SPL_LINUX_TRY_COMPILE([
 722                 #include <linux/fs.h>
 723         ],[
 724                 atomic64_t *ptr __attribute__ ((unused));
 725         ],[
 726                 have_atomic64_t=yes
 727                 AC_DEFINE(HAVE_ATOMIC64_T, 1,
 728                         [kernel defines atomic64_t])
 729         ],[
 730                 have_atomic64_t=no
 731         ])
 732
 733         AS_IF([test "x$enable_atomic_spinlocks" = xcheck], [
 734                 AS_IF([test "x$have_atomic64_t" = xyes], [
 735                         enable_atomic_spinlocks=no
 736                 ],[
 737                         enable_atomic_spinlocks=yes
 738                 ])
 739         ])
 740
 741         AS_IF([test "x$enable_atomic_spinlocks" = xyes], [
 742                 AC_DEFINE([ATOMIC_SPINLOCK], [1],
 743                         [Atomic types use spinlocks])
 744         ],[
 745                 AS_IF([test "x$have_atomic64_t" = xno], [
 746                         AC_MSG_FAILURE(
 747                         [--disable-atomic-spinlocks given but required atomic64 support is unavailable])
 748                 ])
 749         ])
 750
 751         AC_MSG_CHECKING([whether atomic types use spinlocks])
 752         AC_MSG_RESULT([$enable_atomic_spinlocks])
 753
 754         AC_MSG_CHECKING([whether kernel defines atomic64_t])
 755         AC_MSG_RESULT([$have_atomic64_t])
 756 ])