zfs/config/kernel.m4

   1 dnl #
   2 dnl # Default ZFS kernel configuration
   3 dnl #
   4 AC_DEFUN([ZFS_AC_CONFIG_KERNEL], [
   5         ZFS_AC_KERNEL
   6         ZFS_AC_SPL
   7         ZFS_AC_TEST_MODULE
   8         ZFS_AC_KERNEL_CONFIG
   9         ZFS_AC_KERNEL_DECLARE_EVENT_CLASS
  10         ZFS_AC_KERNEL_CURRENT_BIO_TAIL
  11         ZFS_AC_KERNEL_SUBMIT_BIO
  12         ZFS_AC_KERNEL_BDEV_BLOCK_DEVICE_OPERATIONS
  13         ZFS_AC_KERNEL_BLOCK_DEVICE_OPERATIONS_RELEASE_VOID
  14         ZFS_AC_KERNEL_TYPE_FMODE_T
  15         ZFS_AC_KERNEL_KOBJ_NAME_LEN
  16         ZFS_AC_KERNEL_3ARG_BLKDEV_GET
  17         ZFS_AC_KERNEL_BLKDEV_GET_BY_PATH
  18         ZFS_AC_KERNEL_OPEN_BDEV_EXCLUSIVE
  19         ZFS_AC_KERNEL_LOOKUP_BDEV
  20         ZFS_AC_KERNEL_INVALIDATE_BDEV_ARGS
  21         ZFS_AC_KERNEL_BDEV_LOGICAL_BLOCK_SIZE
  22         ZFS_AC_KERNEL_BDEV_PHYSICAL_BLOCK_SIZE
  23         ZFS_AC_KERNEL_BIO_BVEC_ITER
  24         ZFS_AC_KERNEL_BIO_FAILFAST_DTD
  25         ZFS_AC_KERNEL_REQ_FAILFAST_MASK
  26         ZFS_AC_KERNEL_REQ_OP_DISCARD
  27         ZFS_AC_KERNEL_REQ_OP_SECURE_ERASE
  28         ZFS_AC_KERNEL_REQ_OP_FLUSH
  29         ZFS_AC_KERNEL_BIO_BI_OPF
  30         ZFS_AC_KERNEL_BIO_END_IO_T_ARGS
  31         ZFS_AC_KERNEL_BIO_RW_BARRIER
  32         ZFS_AC_KERNEL_BIO_RW_DISCARD
  33         ZFS_AC_KERNEL_BLK_QUEUE_FLUSH
  34         ZFS_AC_KERNEL_BLK_QUEUE_MAX_HW_SECTORS
  35         ZFS_AC_KERNEL_BLK_QUEUE_MAX_SEGMENTS
  36         ZFS_AC_KERNEL_BLK_QUEUE_HAVE_BIO_RW_UNPLUG
  37         ZFS_AC_KERNEL_BLK_QUEUE_HAVE_BLK_PLUG
  38         ZFS_AC_KERNEL_GET_DISK_RO
  39         ZFS_AC_KERNEL_GET_GENDISK
  40         ZFS_AC_KERNEL_HAVE_BIO_SET_OP_ATTRS
  41         ZFS_AC_KERNEL_GENERIC_READLINK_GLOBAL
  42         ZFS_AC_KERNEL_DISCARD_GRANULARITY
  43         ZFS_AC_KERNEL_CONST_XATTR_HANDLER
  44         ZFS_AC_KERNEL_XATTR_HANDLER_NAME
  45         ZFS_AC_KERNEL_XATTR_HANDLER_GET
  46         ZFS_AC_KERNEL_XATTR_HANDLER_SET
  47         ZFS_AC_KERNEL_XATTR_HANDLER_LIST
  48         ZFS_AC_KERNEL_INODE_OWNER_OR_CAPABLE
  49         ZFS_AC_KERNEL_POSIX_ACL_FROM_XATTR_USERNS
  50         ZFS_AC_KERNEL_POSIX_ACL_RELEASE
  51         ZFS_AC_KERNEL_SET_CACHED_ACL_USABLE
  52         ZFS_AC_KERNEL_POSIX_ACL_CHMOD
  53         ZFS_AC_KERNEL_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T
  54         ZFS_AC_KERNEL_POSIX_ACL_VALID_WITH_NS
  55         ZFS_AC_KERNEL_INODE_OPERATIONS_PERMISSION
  56         ZFS_AC_KERNEL_INODE_OPERATIONS_PERMISSION_WITH_NAMEIDATA
  57         ZFS_AC_KERNEL_INODE_OPERATIONS_CHECK_ACL
  58         ZFS_AC_KERNEL_INODE_OPERATIONS_CHECK_ACL_WITH_FLAGS
  59         ZFS_AC_KERNEL_INODE_OPERATIONS_GET_ACL
  60         ZFS_AC_KERNEL_INODE_OPERATIONS_SET_ACL
  61         ZFS_AC_KERNEL_GET_ACL_HANDLE_CACHE
  62         ZFS_AC_KERNEL_SHOW_OPTIONS
  63         ZFS_AC_KERNEL_FILE_INODE
  64         ZFS_AC_KERNEL_FSYNC
  65         ZFS_AC_KERNEL_EVICT_INODE
  66         ZFS_AC_KERNEL_DIRTY_INODE_WITH_FLAGS
  67         ZFS_AC_KERNEL_NR_CACHED_OBJECTS
  68         ZFS_AC_KERNEL_FREE_CACHED_OBJECTS
  69         ZFS_AC_KERNEL_FALLOCATE
  70         ZFS_AC_KERNEL_AIO_FSYNC
  71         ZFS_AC_KERNEL_MKDIR_UMODE_T
  72         ZFS_AC_KERNEL_LOOKUP_NAMEIDATA
  73         ZFS_AC_KERNEL_CREATE_NAMEIDATA
  74         ZFS_AC_KERNEL_GET_LINK
  75         ZFS_AC_KERNEL_PUT_LINK
  76         ZFS_AC_KERNEL_TRUNCATE_RANGE
  77         ZFS_AC_KERNEL_AUTOMOUNT
  78         ZFS_AC_KERNEL_ENCODE_FH_WITH_INODE
  79         ZFS_AC_KERNEL_COMMIT_METADATA
  80         ZFS_AC_KERNEL_CLEAR_INODE
  81         ZFS_AC_KERNEL_SETATTR_PREPARE
  82         ZFS_AC_KERNEL_INSERT_INODE_LOCKED
  83         ZFS_AC_KERNEL_D_MAKE_ROOT
  84         ZFS_AC_KERNEL_D_OBTAIN_ALIAS
  85         ZFS_AC_KERNEL_D_PRUNE_ALIASES
  86         ZFS_AC_KERNEL_D_SET_D_OP
  87         ZFS_AC_KERNEL_D_REVALIDATE_NAMEIDATA
  88         ZFS_AC_KERNEL_CONST_DENTRY_OPERATIONS
  89         ZFS_AC_KERNEL_CHECK_DISK_SIZE_CHANGE
  90         ZFS_AC_KERNEL_TRUNCATE_SETSIZE
  91         ZFS_AC_KERNEL_6ARGS_SECURITY_INODE_INIT_SECURITY
  92         ZFS_AC_KERNEL_CALLBACK_SECURITY_INODE_INIT_SECURITY
  93         ZFS_AC_KERNEL_MOUNT_NODEV
  94         ZFS_AC_KERNEL_SHRINK
  95         ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID
  96         ZFS_AC_KERNEL_S_INSTANCES_LIST_HEAD
  97         ZFS_AC_KERNEL_S_D_OP
  98         ZFS_AC_KERNEL_BDI_SETUP_AND_REGISTER
  99         ZFS_AC_KERNEL_SET_NLINK
 100         ZFS_AC_KERNEL_ELEVATOR_CHANGE
 101         ZFS_AC_KERNEL_5ARG_SGET
 102         ZFS_AC_KERNEL_LSEEK_EXECUTE
 103         ZFS_AC_KERNEL_VFS_ITERATE
 104         ZFS_AC_KERNEL_VFS_RW_ITERATE
 105         ZFS_AC_KERNEL_GENERIC_WRITE_CHECKS
 106         ZFS_AC_KERNEL_KMAP_ATOMIC_ARGS
 107         ZFS_AC_KERNEL_FOLLOW_DOWN_ONE
 108         ZFS_AC_KERNEL_MAKE_REQUEST_FN
 109         ZFS_AC_KERNEL_GENERIC_IO_ACCT
 110         ZFS_AC_KERNEL_RENAME_WANTS_FLAGS
 111         ZFS_AC_KERNEL_HAVE_GENERIC_SETXATTR
 112
 113         AS_IF([test "$LINUX_OBJ" != "$LINUX"], [
 114                 KERNELMAKE_PARAMS="$KERNELMAKE_PARAMS O=$LINUX_OBJ"
 115         ])
 116         AC_SUBST(KERNELMAKE_PARAMS)
 117
 118
 119         dnl # -Wall -fno-strict-aliasing -Wstrict-prototypes and other
 120         dnl # compiler options are added by the kernel build system.
 121         KERNELCPPFLAGS="$KERNELCPPFLAGS $NO_UNUSED_BUT_SET_VARIABLE"
 122         KERNELCPPFLAGS="$KERNELCPPFLAGS $NO_BOOL_COMPARE"
 123         KERNELCPPFLAGS="$KERNELCPPFLAGS -DHAVE_SPL -D_KERNEL"
 124         KERNELCPPFLAGS="$KERNELCPPFLAGS -DTEXT_DOMAIN=\\\"zfs-linux-kernel\\\""
 125
 126         AC_SUBST(KERNELCPPFLAGS)
 127 ])
 128
 129 dnl #
 130 dnl # Detect name used for Module.symvers file in kernel
 131 dnl #
 132 AC_DEFUN([ZFS_AC_MODULE_SYMVERS], [
 133         modpost=$LINUX/scripts/Makefile.modpost
 134         AC_MSG_CHECKING([kernel file name for module symbols])
 135         AS_IF([test "x$enable_linux_builtin" != xyes -a -f "$modpost"], [
 136                 AS_IF([grep -q Modules.symvers $modpost], [
 137                         LINUX_SYMBOLS=Modules.symvers
 138                 ], [
 139                         LINUX_SYMBOLS=Module.symvers
 140                 ])
 141
 142                 AS_IF([test ! -f "$LINUX_OBJ/$LINUX_SYMBOLS"], [
 143                         AC_MSG_ERROR([
 144         *** Please make sure the kernel devel package for your distribution
 145         *** is installed.  If you are building with a custom kernel, make sure the
 146         *** kernel is configured, built, and the '--with-linux=PATH' configure
 147         *** option refers to the location of the kernel source.])
 148                 ])
 149         ], [
 150                 LINUX_SYMBOLS=NONE
 151         ])
 152         AC_MSG_RESULT($LINUX_SYMBOLS)
 153         AC_SUBST(LINUX_SYMBOLS)
 154 ])
 155
 156 dnl #
 157 dnl # Detect the kernel to be built against
 158 dnl #
 159 AC_DEFUN([ZFS_AC_KERNEL], [
 160         AC_ARG_WITH([linux],
 161                 AS_HELP_STRING([--with-linux=PATH],
 162                 [Path to kernel source]),
 163                 [kernelsrc="$withval"])
 164
 165         AC_ARG_WITH(linux-obj,
 166                 AS_HELP_STRING([--with-linux-obj=PATH],
 167                 [Path to kernel build objects]),
 168                 [kernelbuild="$withval"])
 169
 170         AC_MSG_CHECKING([kernel source directory])
 171         AS_IF([test -z "$kernelsrc"], [
 172                 AS_IF([test -e "/lib/modules/$(uname -r)/source"], [
 173                         headersdir="/lib/modules/$(uname -r)/source"
 174                         sourcelink=$(readlink -f "$headersdir")
 175                 ], [test -e "/lib/modules/$(uname -r)/build"], [
 176                         headersdir="/lib/modules/$(uname -r)/build"
 177                         sourcelink=$(readlink -f "$headersdir")
 178                 ], [
 179                         sourcelink=$(ls -1d /usr/src/kernels/* \
 180                                      /usr/src/linux-* \
 181                                      2>/dev/null | grep -v obj | tail -1)
 182                 ])
 183
 184                 AS_IF([test -n "$sourcelink" && test -e ${sourcelink}], [
 185                         kernelsrc=`readlink -f ${sourcelink}`
 186                 ], [
 187                         kernelsrc="[Not found]"
 188                 ])
 189         ], [
 190                 AS_IF([test "$kernelsrc" = "NONE"], [
 191                         kernsrcver=NONE
 192                 ])
 193         ])
 194
 195         AC_MSG_RESULT([$kernelsrc])
 196         AS_IF([test ! -d "$kernelsrc"], [
 197                 AC_MSG_ERROR([
 198         *** Please make sure the kernel devel package for your distribution
 199         *** is installed and then try again.  If that fails, you can specify the
 200         *** location of the kernel source with the '--with-linux=PATH' option.])
 201         ])
 202
 203         AC_MSG_CHECKING([kernel build directory])
 204         AS_IF([test -z "$kernelbuild"], [
 205                 AS_IF([test -e "/lib/modules/$(uname -r)/build"], [
 206                         kernelbuild=`readlink -f /lib/modules/$(uname -r)/build`
 207                 ], [test -d ${kernelsrc}-obj/${target_cpu}/${target_cpu}], [
 208                         kernelbuild=${kernelsrc}-obj/${target_cpu}/${target_cpu}
 209                 ], [test -d ${kernelsrc}-obj/${target_cpu}/default], [
 210                         kernelbuild=${kernelsrc}-obj/${target_cpu}/default
 211                 ], [test -d `dirname ${kernelsrc}`/build-${target_cpu}], [
 212                         kernelbuild=`dirname ${kernelsrc}`/build-${target_cpu}
 213                 ], [
 214                         kernelbuild=${kernelsrc}
 215                 ])
 216         ])
 217         AC_MSG_RESULT([$kernelbuild])
 218
 219         AC_MSG_CHECKING([kernel source version])
 220         utsrelease1=$kernelbuild/include/linux/version.h
 221         utsrelease2=$kernelbuild/include/linux/utsrelease.h
 222         utsrelease3=$kernelbuild/include/generated/utsrelease.h
 223         AS_IF([test -r $utsrelease1 && fgrep -q UTS_RELEASE $utsrelease1], [
 224                 utsrelease=linux/version.h
 225         ], [test -r $utsrelease2 && fgrep -q UTS_RELEASE $utsrelease2], [
 226                 utsrelease=linux/utsrelease.h
 227         ], [test -r $utsrelease3 && fgrep -q UTS_RELEASE $utsrelease3], [
 228                 utsrelease=generated/utsrelease.h
 229         ])
 230
 231         AS_IF([test "$utsrelease"], [
 232                 kernsrcver=`(echo "#include <$utsrelease>";
 233                              echo "kernsrcver=UTS_RELEASE") |
 234                              cpp -I $kernelbuild/include |
 235                              grep "^kernsrcver=" | cut -d \" -f 2`
 236
 237                 AS_IF([test -z "$kernsrcver"], [
 238                         AC_MSG_RESULT([Not found])
 239                         AC_MSG_ERROR([*** Cannot determine kernel version.])
 240                 ])
 241         ], [
 242                 AC_MSG_RESULT([Not found])
 243                 if test "x$enable_linux_builtin" != xyes; then
 244                         AC_MSG_ERROR([*** Cannot find UTS_RELEASE definition.])
 245                 else
 246                         AC_MSG_ERROR([
 247         *** Cannot find UTS_RELEASE definition.
 248         *** Please run 'make prepare' inside the kernel source tree.])
 249                 fi
 250         ])
 251
 252         AC_MSG_RESULT([$kernsrcver])
 253
 254         LINUX=${kernelsrc}
 255         LINUX_OBJ=${kernelbuild}
 256         LINUX_VERSION=${kernsrcver}
 257
 258         AC_SUBST(LINUX)
 259         AC_SUBST(LINUX_OBJ)
 260         AC_SUBST(LINUX_VERSION)
 261
 262         ZFS_AC_MODULE_SYMVERS
 263 ])
 264
 265
 266 dnl #
 267 dnl # Detect the SPL module to be built against
 268 dnl #
 269 AC_DEFUN([ZFS_AC_SPL], [
 270         AC_ARG_WITH([spl],
 271                 AS_HELP_STRING([--with-spl=PATH],
 272                 [Path to spl source]),
 273                 [splsrc="$withval"])
 274
 275         AC_ARG_WITH([spl-obj],
 276                 AS_HELP_STRING([--with-spl-obj=PATH],
 277                 [Path to spl build objects]),
 278                 [splbuild="$withval"])
 279
 280         AC_ARG_WITH([spl-timeout],
 281                 AS_HELP_STRING([--with-spl-timeout=SECS],
 282                 [Wait SECS for SPL header and symver file @<:@default=0@:>@]),
 283                 [timeout="$withval"], [timeout=0])
 284
 285         dnl #
 286         dnl # The existence of spl.release.in is used to identify a valid
 287         dnl # source directory.  In order of preference:
 288         dnl #
 289         splsrc0="/var/lib/dkms/spl/${VERSION}/build"
 290         splsrc1="/usr/local/src/spl-${VERSION}/${LINUX_VERSION}"
 291         splsrc2="/usr/local/src/spl-${VERSION}"
 292         splsrc3="/usr/src/spl-${VERSION}/${LINUX_VERSION}"
 293         splsrc4="/usr/src/spl-${VERSION}"
 294         splsrc5="../spl/"
 295         splsrc6="$LINUX"
 296
 297         AC_MSG_CHECKING([spl source directory])
 298         AS_IF([test -z "${splsrc}"], [
 299                 AS_IF([ test -e "${splsrc0}/spl.release.in"], [
 300                         splsrc=${splsrc0}
 301                 ], [ test -e "${splsrc1}/spl.release.in"], [
 302                         splsrc=${splsrc1}
 303                 ], [ test -e "${splsrc2}/spl.release.in"], [
 304                         splsrc=${splsrc2}
 305                 ], [ test -e "${splsrc3}/spl.release.in"], [
 306                         splsrc=$(readlink -f "${splsrc3}")
 307                 ], [ test -e "${splsrc4}/spl.release.in" ], [
 308                         splsrc=${splsrc4}
 309                 ], [ test -e "${splsrc5}/spl.release.in"], [
 310                         splsrc=$(readlink -f "${splsrc5}")
 311                 ], [ test -e "${splsrc6}/spl.release.in" ], [
 312                         splsrc=${splsrc6}
 313                 ], [
 314                         splsrc="[Not found]"
 315                 ])
 316         ], [
 317                 AS_IF([test "$splsrc" = "NONE"], [
 318                         splbuild=NONE
 319                         splsrcver=NONE
 320                 ])
 321         ])
 322
 323         AC_MSG_RESULT([$splsrc])
 324         AS_IF([ test ! -e "$splsrc/spl.release.in"], [
 325                 AC_MSG_ERROR([
 326         *** Please make sure the kmod spl devel package for your distribution
 327         *** is installed then try again.  If that fails you can specify the
 328         *** location of the spl source with the '--with-spl=PATH' option.])
 329         ])
 330
 331         dnl #
 332         dnl # The existence of the spl_config.h is used to identify a valid
 333         dnl # spl object directory.  In many cases the object and source
 334         dnl # directory are the same, however the objects may also reside
 335         dnl # is a subdirectory named after the kernel version.
 336         dnl #
 337         dnl # This file is supposed to be available after DKMS finishes
 338         dnl # building the SPL kernel module for the target kernel.  The
 339         dnl # '--with-spl-timeout' option can be passed to pause here,
 340         dnl # waiting for the file to appear from a concurrently building
 341         dnl # SPL package.
 342         dnl #
 343         AC_MSG_CHECKING([spl build directory])
 344         while true; do
 345                 AS_IF([test -z "$splbuild"], [
 346                         AS_IF([ test -e "${splsrc}/${LINUX_VERSION}/spl_config.h" ], [
 347                                 splbuild="${splsrc}/${LINUX_VERSION}"
 348                         ], [ test -e "${splsrc}/spl_config.h" ], [
 349                                 splbuild="${splsrc}"
 350                         ], [ find -L "${splsrc}" -name spl_config.h 2> /dev/null | grep -wq spl_config.h ], [
 351                                 splbuild=$(find -L "${splsrc}" -name spl_config.h | sed 's,/spl_config.h,,')
 352                         ], [
 353                                 splbuild="[Not found]"
 354                         ])
 355                 ])
 356                 AS_IF([test -e "$splbuild/spl_config.h" -o $timeout -le 0], [
 357                         break;
 358                 ], [
 359                         sleep 1
 360                         timeout=$((timeout-1))
 361                 ])
 362         done
 363
 364         AC_MSG_RESULT([$splbuild])
 365         AS_IF([ ! test -e "$splbuild/spl_config.h"], [
 366                 AC_MSG_ERROR([
 367         *** Please make sure the kmod spl devel <kernel> package for your
 368         *** distribution is installed then try again.  If that fails you
 369         *** can specify the location of the spl objects with the
 370         *** '--with-spl-obj=PATH' option.])
 371         ])
 372
 373         AC_MSG_CHECKING([spl source version])
 374         AS_IF([test -r $splbuild/spl_config.h &&
 375                 fgrep -q SPL_META_VERSION $splbuild/spl_config.h], [
 376
 377                 splsrcver=`(echo "#include <spl_config.h>";
 378                             echo "splsrcver=SPL_META_VERSION-SPL_META_RELEASE") |
 379                             cpp -I $splbuild |
 380                             grep "^splsrcver=" | tr -d \" | cut -d= -f2`
 381         ])
 382
 383         AS_IF([test -z "$splsrcver"], [
 384                 AC_MSG_RESULT([Not found])
 385                 AC_MSG_ERROR([
 386         *** Cannot determine the version of the spl source.
 387         *** Please prepare the spl source before running this script])
 388         ])
 389
 390         AC_MSG_RESULT([$splsrcver])
 391
 392         SPL=${splsrc}
 393         SPL_OBJ=${splbuild}
 394         SPL_VERSION=${splsrcver}
 395
 396         AC_SUBST(SPL)
 397         AC_SUBST(SPL_OBJ)
 398         AC_SUBST(SPL_VERSION)
 399
 400         dnl #
 401         dnl # Detect the name used for the SPL Module.symvers file.  If one
 402         dnl # does not exist this is likely because the SPL has been configured
 403         dnl # but not built.  The '--with-spl-timeout' option can be passed
 404         dnl # to pause here, waiting for the file to appear from a concurrently
 405         dnl # building SPL package.  If the file does not appear in time, a good
 406         dnl # guess is made as to what this file will be named based on what it
 407         dnl # is named in the kernel build products.  This file will first be
 408         dnl # used at link time so if the guess is wrong the build will fail
 409         dnl # then.  This unfortunately means the ZFS package does not contain a
 410         dnl # reliable mechanism to detect symbols exported by the SPL at
 411         dnl # configure time.
 412         dnl #
 413         AC_MSG_CHECKING([spl file name for module symbols])
 414         SPL_SYMBOLS=NONE
 415
 416         while true; do
 417                 AS_IF([test -r $SPL_OBJ/Module.symvers], [
 418                         SPL_SYMBOLS=Module.symvers
 419                 ], [test -r $SPL_OBJ/Modules.symvers], [
 420                         SPL_SYMBOLS=Modules.symvers
 421                 ], [test -r $SPL_OBJ/module/Module.symvers], [
 422                         SPL_SYMBOLS=Module.symvers
 423                 ], [test -r $SPL_OBJ/module/Modules.symvers], [
 424                         SPL_SYMBOLS=Modules.symvers
 425                 ])
 426
 427                 AS_IF([test $SPL_SYMBOLS != NONE -o $timeout -le 0], [
 428                         break;
 429                 ], [
 430                         sleep 1
 431                         timeout=$((timeout-1))
 432                 ])
 433         done
 434
 435         AS_IF([test "$SPL_SYMBOLS" = NONE], [
 436                 SPL_SYMBOLS=$LINUX_SYMBOLS
 437         ])
 438
 439         AC_MSG_RESULT([$SPL_SYMBOLS])
 440         AC_SUBST(SPL_SYMBOLS)
 441 ])
 442
 443 dnl #
 444 dnl # Basic toolchain sanity check.
 445 dnl #
 446 AC_DEFUN([ZFS_AC_TEST_MODULE], [
 447         AC_MSG_CHECKING([whether modules can be built])
 448         ZFS_LINUX_TRY_COMPILE([],[],[
 449                 AC_MSG_RESULT([yes])
 450         ],[
 451                 AC_MSG_RESULT([no])
 452                 if test "x$enable_linux_builtin" != xyes; then
 453                         AC_MSG_ERROR([*** Unable to build an empty module.])
 454                 else
 455                         AC_MSG_ERROR([
 456         *** Unable to build an empty module.
 457         *** Please run 'make scripts' inside the kernel source tree.])
 458                 fi
 459         ])
 460 ])
 461
 462 dnl #
 463 dnl # Certain kernel build options are not supported.  These must be
 464 dnl # detected at configure time and cause a build failure.  Otherwise
 465 dnl # modules may be successfully built that behave incorrectly.
 466 dnl #
 467 AC_DEFUN([ZFS_AC_KERNEL_CONFIG], [
 468         AS_IF([test "x$cross_compiling" != xyes], [
 469                 AC_RUN_IFELSE([
 470                         AC_LANG_PROGRAM([
 471                                 #include "$LINUX/include/linux/license.h"
 472                         ], [
 473                                 return !license_is_gpl_compatible("$ZFS_META_LICENSE");
 474                         ])
 475                 ], [
 476                         AC_DEFINE([ZFS_IS_GPL_COMPATIBLE], [1],
 477                             [Define to 1 if GPL-only symbols can be used])
 478                 ], [
 479                 ])
 480         ])
 481
 482         ZFS_AC_KERNEL_CONFIG_THREAD_SIZE
 483         ZFS_AC_KERNEL_CONFIG_DEBUG_LOCK_ALLOC
 484 ])
 485
 486 dnl #
 487 dnl # Check configured THREAD_SIZE
 488 dnl #
 489 dnl # The stack size will vary by architecture, but as of Linux 3.15 on x86_64
 490 dnl # the default thread stack size was increased to 16K from 8K.  Therefore,
 491 dnl # on newer kernels and some architectures stack usage optimizations can be
 492 dnl # conditionally applied to improve performance without negatively impacting
 493 dnl # stability.
 494 dnl #
 495 AC_DEFUN([ZFS_AC_KERNEL_CONFIG_THREAD_SIZE], [
 496         AC_MSG_CHECKING([whether kernel was built with 16K or larger stacks])
 497         ZFS_LINUX_TRY_COMPILE([
 498                 #include <linux/module.h>
 499         ],[
 500                 #if (THREAD_SIZE < 16384)
 501                 #error "THREAD_SIZE is less than 16K"
 502                 #endif
 503         ],[
 504                 AC_MSG_RESULT([yes])
 505                 AC_DEFINE(HAVE_LARGE_STACKS, 1, [kernel has large stacks])
 506         ],[
 507                 AC_MSG_RESULT([no])
 508         ])
 509 ])
 510
 511 dnl #
 512 dnl # Check CONFIG_DEBUG_LOCK_ALLOC
 513 dnl #
 514 dnl # This is typically only set for debug kernels because it comes with
 515 dnl # a performance penalty.  However, when it is set it maps the non-GPL
 516 dnl # symbol mutex_lock() to the GPL-only mutex_lock_nested() symbol.
 517 dnl # This will cause a failure at link time which we'd rather know about
 518 dnl # at compile time.
 519 dnl #
 520 dnl # Since we plan to pursue making mutex_lock_nested() a non-GPL symbol
 521 dnl # with the upstream community we add a check to detect this case.
 522 dnl #
 523 AC_DEFUN([ZFS_AC_KERNEL_CONFIG_DEBUG_LOCK_ALLOC], [
 524
 525         ZFS_LINUX_CONFIG([DEBUG_LOCK_ALLOC], [
 526                 AC_MSG_CHECKING([whether mutex_lock() is GPL-only])
 527                 tmp_flags="$EXTRA_KCFLAGS"
 528                 ZFS_LINUX_TRY_COMPILE([
 529                         #include <linux/module.h>
 530                         #include <linux/mutex.h>
 531
 532                         MODULE_LICENSE("$ZFS_META_LICENSE");
 533                 ],[
 534                         struct mutex lock;
 535
 536                         mutex_init(&lock);
 537                         mutex_lock(&lock);
 538                         mutex_unlock(&lock);
 539                 ],[
 540                         AC_MSG_RESULT(no)
 541                 ],[
 542                         AC_MSG_RESULT(yes)
 543                         AC_MSG_ERROR([
 544         *** Kernel built with CONFIG_DEBUG_LOCK_ALLOC which is incompatible
 545         *** with the CDDL license and will prevent the module linking stage
 546         *** from succeeding.  You must rebuild your kernel without this
 547         *** option enabled.])
 548                 ])
 549                 EXTRA_KCFLAGS="$tmp_flags"
 550         ], [])
 551 ])
 552
 553 dnl #
 554 dnl # ZFS_LINUX_CONFTEST_H
 555 dnl #
 556 AC_DEFUN([ZFS_LINUX_CONFTEST_H], [
 557 cat - <<_ACEOF >conftest.h
 558 $1
 559 _ACEOF
 560 ])
 561
 562 dnl #
 563 dnl # ZFS_LINUX_CONFTEST_C
 564 dnl #
 565 AC_DEFUN([ZFS_LINUX_CONFTEST_C], [
 566 cat confdefs.h - <<_ACEOF >conftest.c
 567 $1
 568 _ACEOF
 569 ])
 570
 571 dnl #
 572 dnl # ZFS_LANG_PROGRAM(C)([PROLOGUE], [BODY])
 573 dnl #
 574 m4_define([ZFS_LANG_PROGRAM], [
 575 $1
 576 int
 577 main (void)
 578 {
 579 dnl Do *not* indent the following line: there may be CPP directives.
 580 dnl Don't move the `;' right after for the same reason.
 581 $2
 582   ;
 583   return 0;
 584 }
 585 ])
 586
 587 dnl #
 588 dnl # ZFS_LINUX_COMPILE_IFELSE / like AC_COMPILE_IFELSE
 589 dnl #
 590 AC_DEFUN([ZFS_LINUX_COMPILE_IFELSE], [
 591         m4_ifvaln([$1], [ZFS_LINUX_CONFTEST_C([$1])])
 592         m4_ifvaln([$6], [ZFS_LINUX_CONFTEST_H([$6])], [ZFS_LINUX_CONFTEST_H([])])
 593         rm -Rf build && mkdir -p build && touch build/conftest.mod.c
 594         echo "obj-m := conftest.o" >build/Makefile
 595         modpost_flag=''
 596         test "x$enable_linux_builtin" = xyes && modpost_flag='modpost=true' # fake modpost stage
 597         AS_IF(
 598                 [AC_TRY_COMMAND(cp conftest.c conftest.h build && make [$2] -C $LINUX_OBJ EXTRA_CFLAGS="-Werror $EXTRA_KCFLAGS" $ARCH_UM M=$PWD/build $modpost_flag) >/dev/null && AC_TRY_COMMAND([$3])],
 599                 [$4],
 600                 [_AC_MSG_LOG_CONFTEST m4_ifvaln([$5],[$5])]
 601         )
 602         rm -Rf build
 603 ])
 604
 605 dnl #
 606 dnl # ZFS_LINUX_TRY_COMPILE like AC_TRY_COMPILE
 607 dnl #
 608 AC_DEFUN([ZFS_LINUX_TRY_COMPILE],
 609         [ZFS_LINUX_COMPILE_IFELSE(
 610         [AC_LANG_SOURCE([ZFS_LANG_PROGRAM([[$1]], [[$2]])])],
 611         [modules],
 612         [test -s build/conftest.o],
 613         [$3], [$4])
 614 ])
 615
 616 dnl #
 617 dnl # ZFS_LINUX_CONFIG
 618 dnl #
 619 AC_DEFUN([ZFS_LINUX_CONFIG],
 620         [AC_MSG_CHECKING([whether kernel was built with CONFIG_$1])
 621         ZFS_LINUX_TRY_COMPILE([
 622                 #include <linux/module.h>
 623         ],[
 624                 #ifndef CONFIG_$1
 625                 #error CONFIG_$1 not #defined
 626                 #endif
 627         ],[
 628                 AC_MSG_RESULT([yes])
 629                 $2
 630         ],[
 631                 AC_MSG_RESULT([no])
 632                 $3
 633         ])
 634 ])
 635
 636 dnl #
 637 dnl # ZFS_CHECK_SYMBOL_EXPORT
 638 dnl # check symbol exported or not
 639 dnl #
 640 AC_DEFUN([ZFS_CHECK_SYMBOL_EXPORT], [
 641         grep -q -E '[[[:space:]]]$1[[[:space:]]]' \
 642                 $LINUX_OBJ/$LINUX_SYMBOLS 2>/dev/null
 643         rc=$?
 644         if test $rc -ne 0; then
 645                 export=0
 646                 for file in $2; do
 647                         grep -q -E "EXPORT_SYMBOL.*($1)" \
 648                                 "$LINUX/$file" 2>/dev/null
 649                         rc=$?
 650                         if test $rc -eq 0; then
 651                                 export=1
 652                                 break;
 653                         fi
 654                 done
 655                 if test $export -eq 0; then :
 656                         $4
 657                 else :
 658                         $3
 659                 fi
 660         else :
 661                 $3
 662         fi
 663 ])
 664
 665 dnl #
 666 dnl # ZFS_LINUX_TRY_COMPILE_SYMBOL
 667 dnl # like ZFS_LINUX_TRY_COMPILE, except ZFS_CHECK_SYMBOL_EXPORT
 668 dnl # is called if not compiling for builtin
 669 dnl #
 670 AC_DEFUN([ZFS_LINUX_TRY_COMPILE_SYMBOL], [
 671         ZFS_LINUX_TRY_COMPILE([$1], [$2], [rc=0], [rc=1])
 672         if test $rc -ne 0; then :
 673                 $6
 674         else
 675                 if test "x$enable_linux_builtin" != xyes; then
 676                         ZFS_CHECK_SYMBOL_EXPORT([$3], [$4], [rc=0], [rc=1])
 677                 fi
 678                 if test $rc -ne 0; then :
 679                         $6
 680                 else :
 681                         $5
 682                 fi
 683         fi
 684 ])
 685
 686 dnl #
 687 dnl # ZFS_LINUX_TRY_COMPILE_HEADER
 688 dnl # like ZFS_LINUX_TRY_COMPILE, except the contents conftest.h are
 689 dnl # provided via the fifth parameter
 690 dnl #
 691 AC_DEFUN([ZFS_LINUX_TRY_COMPILE_HEADER],
 692         [ZFS_LINUX_COMPILE_IFELSE(
 693         [AC_LANG_SOURCE([ZFS_LANG_PROGRAM([[$1]], [[$2]])])],
 694         [modules],
 695         [test -s build/conftest.o],
 696         [$3], [$4], [$5])
 697 ])