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 ###############################################################################
9 AC_DEFUN([SPL_AC_CONFIG_KERNEL], [
12 if test "${LINUX_OBJ}" != "${LINUX}"; then
13 KERNELMAKE_PARAMS="$KERNELMAKE_PARAMS O=$LINUX_OBJ"
15 AC_SUBST(KERNELMAKE_PARAMS)
17 KERNELCPPFLAGS="$KERNELCPPFLAGS -Wstrict-prototypes"
18 AC_SUBST(KERNELCPPFLAGS)
21 SPL_AC_ATOMIC_SPINLOCK
22 SPL_AC_SHRINKER_CALLBACK
24 SPL_AC_CONFIG_TRIM_UNUSED_KSYMS
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
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
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
45 SPL_AC_KMEM_CACHE_ALLOCFLAGS
49 SPL_AC_KMEM_CACHE_CREATE_USERCOPY
50 SPL_AC_WAIT_QUEUE_ENTRY_T
51 SPL_AC_WAIT_QUEUE_HEAD_ENTRY
52 SPL_AC_IO_SCHEDULE_TIMEOUT
55 SPL_AC_KERNEL_TIMER_FUNCTION_TIMER_LIST
58 AC_DEFUN([SPL_AC_MODULE_SYMVERS], [
59 modpost=$LINUX/scripts/Makefile.modpost
60 AC_MSG_CHECKING([kernel file name for module symbols])
61 if test "x$enable_linux_builtin" != xyes -a -f "$modpost"; then
62 if grep -q Modules.symvers $modpost; then
63 LINUX_SYMBOLS=Modules.symvers
65 LINUX_SYMBOLS=Module.symvers
68 if ! test -f "$LINUX_OBJ/$LINUX_SYMBOLS"; then
70 *** Please make sure the kernel devel package for your distribution
71 *** is installed. If you are building with a custom kernel, make sure the
72 *** kernel is configured, built, and the '--with-linux=PATH' configure
73 *** option refers to the location of the kernel source.])
78 AC_MSG_RESULT($LINUX_SYMBOLS)
79 AC_SUBST(LINUX_SYMBOLS)
82 AC_DEFUN([SPL_AC_KERNEL], [
84 AS_HELP_STRING([--with-linux=PATH],
85 [Path to kernel source]),
86 [kernelsrc="$withval"])
88 AC_ARG_WITH([linux-obj],
89 AS_HELP_STRING([--with-linux-obj=PATH],
90 [Path to kernel build objects]),
91 [kernelbuild="$withval"])
93 AC_MSG_CHECKING([kernel source directory])
94 if test -z "$kernelsrc"; then
95 if test -e "/lib/modules/$(uname -r)/source"; then
96 headersdir="/lib/modules/$(uname -r)/source"
97 sourcelink=$(readlink -f "$headersdir")
98 elif test -e "/lib/modules/$(uname -r)/build"; then
99 headersdir="/lib/modules/$(uname -r)/build"
100 sourcelink=$(readlink -f "$headersdir")
102 sourcelink=$(ls -1d /usr/src/kernels/* \
104 2>/dev/null | grep -v obj | tail -1)
107 if test -n "$sourcelink" && test -e ${sourcelink}; then
108 kernelsrc=`readlink -f ${sourcelink}`
110 kernelsrc="[Not found]"
113 if test "$kernelsrc" = "NONE"; then
119 AC_MSG_RESULT([$kernelsrc])
120 if test ! -d "$kernelsrc"; then
122 *** Please make sure the kernel devel package for your distribution
123 *** is installed and then try again. If that fails, you can specify the
124 *** location of the kernel source with the '--with-linux=PATH' option.])
127 AC_MSG_CHECKING([kernel build directory])
128 if test -z "$kernelbuild"; then
129 if test x$withlinux != xyes -a -e "/lib/modules/$(uname -r)/build"; then
130 kernelbuild=`readlink -f /lib/modules/$(uname -r)/build`
131 elif test -d ${kernelsrc}-obj/${target_cpu}/${target_cpu}; then
132 kernelbuild=${kernelsrc}-obj/${target_cpu}/${target_cpu}
133 elif test -d ${kernelsrc}-obj/${target_cpu}/default; then
134 kernelbuild=${kernelsrc}-obj/${target_cpu}/default
135 elif test -d `dirname ${kernelsrc}`/build-${target_cpu}; then
136 kernelbuild=`dirname ${kernelsrc}`/build-${target_cpu}
138 kernelbuild=${kernelsrc}
141 AC_MSG_RESULT([$kernelbuild])
143 AC_MSG_CHECKING([kernel source version])
144 utsrelease1=$kernelbuild/include/linux/version.h
145 utsrelease2=$kernelbuild/include/linux/utsrelease.h
146 utsrelease3=$kernelbuild/include/generated/utsrelease.h
147 if test -r $utsrelease1 && fgrep -q UTS_RELEASE $utsrelease1; then
148 utsrelease=linux/version.h
149 elif test -r $utsrelease2 && fgrep -q UTS_RELEASE $utsrelease2; then
150 utsrelease=linux/utsrelease.h
151 elif test -r $utsrelease3 && fgrep -q UTS_RELEASE $utsrelease3; then
152 utsrelease=generated/utsrelease.h
155 if test "$utsrelease"; then
156 kernsrcver=`(echo "#include <$utsrelease>";
157 echo "kernsrcver=UTS_RELEASE") |
158 cpp -I $kernelbuild/include |
159 grep "^kernsrcver=" | cut -d \" -f 2`
161 if test -z "$kernsrcver"; then
162 AC_MSG_RESULT([Not found])
163 AC_MSG_ERROR([*** Cannot determine kernel version.])
166 AC_MSG_RESULT([Not found])
167 if test "x$enable_linux_builtin" != xyes; then
168 AC_MSG_ERROR([*** Cannot find UTS_RELEASE definition.])
171 *** Cannot find UTS_RELEASE definition.
172 *** Please run 'make prepare' inside the kernel source tree.])
176 AC_MSG_RESULT([$kernsrcver])
179 LINUX_OBJ=${kernelbuild}
180 LINUX_VERSION=${kernsrcver}
184 AC_SUBST(LINUX_VERSION)
186 SPL_AC_MODULE_SYMVERS
190 dnl # Default SPL user configuration
192 AC_DEFUN([SPL_AC_CONFIG_USER], [])
195 dnl # Check for rpm+rpmbuild to build RPM packages. If these tools
196 dnl # are missing, it is non-fatal, but you will not be able to build
197 dnl # RPM packages and will be warned if you try too.
199 dnl # By default, the generic spec file will be used because it requires
200 dnl # minimal dependencies. Distribution specific spec files can be
201 dnl # placed under the 'rpm/<distribution>' directory and enabled using
202 dnl # the --with-spec=<distribution> configure option.
204 AC_DEFUN([SPL_AC_RPM], [
208 AC_MSG_CHECKING([whether $RPM is available])
209 AS_IF([tmp=$($RPM --version 2>/dev/null)], [
210 RPM_VERSION=$(echo $tmp | $AWK '/RPM/ { print $[3] }')
212 AC_MSG_RESULT([$HAVE_RPM ($RPM_VERSION)])
215 AC_MSG_RESULT([$HAVE_RPM])
218 AC_MSG_CHECKING([whether $RPMBUILD is available])
219 AS_IF([tmp=$($RPMBUILD --version 2>/dev/null)], [
220 RPMBUILD_VERSION=$(echo $tmp | $AWK '/RPM/ { print $[3] }')
222 AC_MSG_RESULT([$HAVE_RPMBUILD ($RPMBUILD_VERSION)])
225 AC_MSG_RESULT([$HAVE_RPMBUILD])
228 RPM_DEFINE_COMMON='--define "$(DEBUG_SPL) 1"'
229 RPM_DEFINE_COMMON+=' --define "$(DEBUG_KMEM) 1"'
230 RPM_DEFINE_COMMON+=' --define "$(DEBUG_KMEM_TRACKING) 1"'
232 RPM_DEFINE_KMOD='--define "kernels $(LINUX_VERSION)"'
233 RPM_DEFINE_KMOD+=' --define "_wrong_version_format_terminate_build 0"'
236 SRPM_DEFINE_COMMON='--define "build_src_rpm 1"'
241 RPM_SPEC_DIR="rpm/generic"
243 AS_HELP_STRING([--with-spec=SPEC],
244 [Spec files 'generic|redhat']),
245 [RPM_SPEC_DIR="rpm/$withval"])
247 AC_MSG_CHECKING([whether spec files are available])
248 AC_MSG_RESULT([yes ($RPM_SPEC_DIR/*.spec.in)])
252 AC_SUBST(RPM_VERSION)
254 AC_SUBST(HAVE_RPMBUILD)
256 AC_SUBST(RPMBUILD_VERSION)
258 AC_SUBST(RPM_SPEC_DIR)
259 AC_SUBST(RPM_DEFINE_UTIL)
260 AC_SUBST(RPM_DEFINE_KMOD)
261 AC_SUBST(RPM_DEFINE_DKMS)
262 AC_SUBST(RPM_DEFINE_COMMON)
263 AC_SUBST(SRPM_DEFINE_UTIL)
264 AC_SUBST(SRPM_DEFINE_KMOD)
265 AC_SUBST(SRPM_DEFINE_DKMS)
266 AC_SUBST(SRPM_DEFINE_COMMON)
270 dnl # Check for dpkg+dpkg-buildpackage to build DEB packages. If these
271 dnl # tools are missing it is non-fatal but you will not be able to build
272 dnl # DEB packages and will be warned if you try too.
274 AC_DEFUN([SPL_AC_DPKG], [
276 DPKGBUILD=dpkg-buildpackage
278 AC_MSG_CHECKING([whether $DPKG is available])
279 AS_IF([tmp=$($DPKG --version 2>/dev/null)], [
280 DPKG_VERSION=$(echo $tmp | $AWK '/Debian/ { print $[7] }')
282 AC_MSG_RESULT([$HAVE_DPKG ($DPKG_VERSION)])
285 AC_MSG_RESULT([$HAVE_DPKG])
288 AC_MSG_CHECKING([whether $DPKGBUILD is available])
289 AS_IF([tmp=$($DPKGBUILD --version 2>/dev/null)], [
290 DPKGBUILD_VERSION=$(echo $tmp | \
291 $AWK '/Debian/ { print $[4] }' | cut -f-4 -d'.')
293 AC_MSG_RESULT([$HAVE_DPKGBUILD ($DPKGBUILD_VERSION)])
296 AC_MSG_RESULT([$HAVE_DPKGBUILD])
301 AC_SUBST(DPKG_VERSION)
303 AC_SUBST(HAVE_DPKGBUILD)
305 AC_SUBST(DPKGBUILD_VERSION)
309 dnl # Until native packaging for various different packing systems
310 dnl # can be added the least we can do is attempt to use alien to
311 dnl # convert the RPM packages to the needed package type. This is
312 dnl # a hack but so far it has worked reasonable well.
314 AC_DEFUN([SPL_AC_ALIEN], [
317 AC_MSG_CHECKING([whether $ALIEN is available])
318 AS_IF([tmp=$($ALIEN --version 2>/dev/null)], [
319 ALIEN_VERSION=$(echo $tmp | $AWK '{ print $[3] }')
321 AC_MSG_RESULT([$HAVE_ALIEN ($ALIEN_VERSION)])
324 AC_MSG_RESULT([$HAVE_ALIEN])
329 AC_SUBST(ALIEN_VERSION)
333 dnl # Using the VENDOR tag from config.guess set the default
334 dnl # package type for 'make pkg': (rpm | deb | tgz)
336 AC_DEFUN([SPL_AC_DEFAULT_PACKAGE], [
337 AC_MSG_CHECKING([linux distribution])
338 if test -f /etc/toss-release ; then
340 elif test -f /etc/fedora-release ; then
342 elif test -f /etc/redhat-release ; then
344 elif test -f /etc/gentoo-release ; then
346 elif test -f /etc/arch-release ; then
348 elif test -f /etc/SuSE-release ; then
350 elif test -f /etc/slackware-version ; then
352 elif test -f /etc/lunar.release ; then
354 elif test -f /etc/lsb-release ; then
356 elif test -f /etc/debian_version ; then
361 AC_MSG_RESULT([$VENDOR])
364 AC_MSG_CHECKING([default package type])
366 toss) DEFAULT_PACKAGE=rpm ;;
367 redhat) DEFAULT_PACKAGE=rpm ;;
368 fedora) DEFAULT_PACKAGE=rpm ;;
369 gentoo) DEFAULT_PACKAGE=tgz ;;
370 arch) DEFAULT_PACKAGE=tgz ;;
371 sles) DEFAULT_PACKAGE=rpm ;;
372 slackware) DEFAULT_PACKAGE=tgz ;;
373 lunar) DEFAULT_PACKAGE=tgz ;;
374 ubuntu) DEFAULT_PACKAGE=deb ;;
375 debian) DEFAULT_PACKAGE=deb ;;
376 *) DEFAULT_PACKAGE=rpm ;;
379 AC_MSG_RESULT([$DEFAULT_PACKAGE])
380 AC_SUBST(DEFAULT_PACKAGE)
384 dnl # Default SPL user configuration
386 AC_DEFUN([SPL_AC_PACKAGE], [
387 SPL_AC_DEFAULT_PACKAGE
393 AC_DEFUN([SPL_AC_LICENSE], [
394 AC_MSG_CHECKING([spl author])
395 AC_MSG_RESULT([$SPL_META_AUTHOR])
397 AC_MSG_CHECKING([spl license])
398 AC_MSG_RESULT([$SPL_META_LICENSE])
401 AC_DEFUN([SPL_AC_CONFIG], [
403 AC_ARG_WITH([config],
404 AS_HELP_STRING([--with-config=CONFIG],
405 [Config file 'kernel|user|all|srpm']),
406 [SPL_CONFIG="$withval"])
407 AC_ARG_ENABLE([linux-builtin],
408 [AC_HELP_STRING([--enable-linux-builtin],
409 [Configure for builtin in-tree kernel modules @<:@default=no@:>@])],
411 [enable_linux_builtin=no])
413 AC_MSG_CHECKING([spl config])
414 AC_MSG_RESULT([$SPL_CONFIG]);
417 case "$SPL_CONFIG" in
418 kernel) SPL_AC_CONFIG_KERNEL ;;
419 user) SPL_AC_CONFIG_USER ;;
420 all) SPL_AC_CONFIG_KERNEL
421 SPL_AC_CONFIG_USER ;;
424 AC_MSG_RESULT([Error!])
425 AC_MSG_ERROR([Bad value "$SPL_CONFIG" for --with-config,
426 user kernel|user|all|srpm]) ;;
429 AM_CONDITIONAL([CONFIG_USER],
430 [test "$SPL_CONFIG" = user -o "$SPL_CONFIG" = all])
431 AM_CONDITIONAL([CONFIG_KERNEL],
432 [test "$SPL_CONFIG" = kernel -o "$SPL_CONFIG" = all] &&
433 [test "x$enable_linux_builtin" != xyes ])
437 dnl # Enable if the SPL should be compiled with internal debugging enabled.
438 dnl # By default this support is disabled.
440 AC_DEFUN([SPL_AC_DEBUG], [
441 AC_MSG_CHECKING([whether debugging is enabled])
442 AC_ARG_ENABLE([debug],
443 [AS_HELP_STRING([--enable-debug],
444 [Enable generic debug support @<:@default=no@:>@])],
448 AS_IF([test "x$enable_debug" = xyes],
450 KERNELCPPFLAGS="${KERNELCPPFLAGS} -DDEBUG -Werror"
451 DEBUG_CFLAGS="-DDEBUG -Werror"
452 DEBUG_SPL="_with_debug"
454 KERNELCPPFLAGS="${KERNELCPPFLAGS} -DNDEBUG"
455 DEBUG_CFLAGS="-DNDEBUG"
456 DEBUG_SPL="_without_debug"
459 AC_SUBST(DEBUG_CFLAGS)
461 AC_MSG_RESULT([$enable_debug])
465 dnl # Enabled by default it provides a minimal level of memory tracking.
466 dnl # A total count of bytes allocated is kept for each alloc and free.
467 dnl # Then at module unload time a report to the console will be printed
468 dnl # if memory was leaked.
470 AC_DEFUN([SPL_AC_DEBUG_KMEM], [
471 AC_ARG_ENABLE([debug-kmem],
472 [AS_HELP_STRING([--enable-debug-kmem],
473 [Enable basic kmem accounting @<:@default=no@:>@])],
475 [enable_debug_kmem=no])
477 AS_IF([test "x$enable_debug_kmem" = xyes],
479 KERNELCPPFLAGS="${KERNELCPPFLAGS} -DDEBUG_KMEM"
480 DEBUG_KMEM="_with_debug_kmem"
481 AC_DEFINE([DEBUG_KMEM], [1],
482 [Define to 1 to enable basic kmem accounting])
484 DEBUG_KMEM="_without_debug_kmem"
488 AC_MSG_CHECKING([whether basic kmem accounting is enabled])
489 AC_MSG_RESULT([$enable_debug_kmem])
493 dnl # Disabled by default it provides detailed memory tracking. This
494 dnl # feature also requires --enable-debug-kmem to be set. When enabled
495 dnl # not only will total bytes be tracked but also the location of every
496 dnl # alloc and free. When the SPL module is unloaded a list of all leaked
497 dnl # addresses and where they were allocated will be dumped to the console.
498 dnl # Enabling this feature has a significant impact on performance but it
499 dnl # makes finding memory leaks pretty straight forward.
501 AC_DEFUN([SPL_AC_DEBUG_KMEM_TRACKING], [
502 AC_ARG_ENABLE([debug-kmem-tracking],
503 [AS_HELP_STRING([--enable-debug-kmem-tracking],
504 [Enable detailed kmem tracking @<:@default=no@:>@])],
506 [enable_debug_kmem_tracking=no])
508 AS_IF([test "x$enable_debug_kmem_tracking" = xyes],
510 KERNELCPPFLAGS="${KERNELCPPFLAGS} -DDEBUG_KMEM_TRACKING"
511 DEBUG_KMEM_TRACKING="_with_debug_kmem_tracking"
512 AC_DEFINE([DEBUG_KMEM_TRACKING], [1],
513 [Define to 1 to enable detailed kmem tracking])
515 DEBUG_KMEM_TRACKING="_without_debug_kmem_tracking"
518 AC_SUBST(DEBUG_KMEM_TRACKING)
519 AC_MSG_CHECKING([whether detailed kmem tracking is enabled])
520 AC_MSG_RESULT([$enable_debug_kmem_tracking])
524 dnl # SPL_LINUX_CONFTEST
526 AC_DEFUN([SPL_LINUX_CONFTEST], [
527 cat confdefs.h - <<_ACEOF >conftest.c
533 dnl # SPL_LANG_PROGRAM(C)([PROLOGUE], [BODY])
535 m4_define([SPL_LANG_PROGRAM], [
540 dnl Do *not* indent the following line: there may be CPP directives.
541 dnl Don't move the `;' right after for the same reason.
549 dnl # SPL_LINUX_COMPILE_IFELSE / like AC_COMPILE_IFELSE
551 AC_DEFUN([SPL_LINUX_COMPILE_IFELSE], [
552 m4_ifvaln([$1], [SPL_LINUX_CONFTEST([$1])])
553 rm -Rf build && mkdir -p build && touch build/conftest.mod.c
554 echo "obj-m := conftest.o" >build/Makefile
556 test "x$enable_linux_builtin" = xyes && modpost_flag='modpost=true' # fake modpost stage
558 [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 [_AC_MSG_LOG_CONFTEST m4_ifvaln([$5],[$5])]
566 dnl # SPL_LINUX_TRY_COMPILE like AC_TRY_COMPILE
568 AC_DEFUN([SPL_LINUX_TRY_COMPILE],
569 [SPL_LINUX_COMPILE_IFELSE(
570 [AC_LANG_SOURCE([SPL_LANG_PROGRAM([[$1]], [[$2]])])],
572 [test -s build/conftest.o],
577 dnl # SPL_CHECK_SYMBOL_EXPORT
578 dnl # check symbol exported or not
580 AC_DEFUN([SPL_CHECK_SYMBOL_EXPORT], [
581 grep -q -E '[[[:space:]]]$1[[[:space:]]]' \
582 $LINUX_OBJ/Module*.symvers 2>/dev/null
584 if test $rc -ne 0; then
587 grep -q -E "EXPORT_SYMBOL.*($1)" \
588 "$LINUX_OBJ/$file" 2>/dev/null
590 if test $rc -eq 0; then
595 if test $export -eq 0; then :
606 dnl # SPL_LINUX_TRY_COMPILE_SYMBOL
607 dnl # like SPL_LINUX_TRY_COMPILE, except SPL_CHECK_SYMBOL_EXPORT
608 dnl # is called if not compiling for builtin
610 AC_DEFUN([SPL_LINUX_TRY_COMPILE_SYMBOL], [
611 SPL_LINUX_TRY_COMPILE([$1], [$2], [rc=0], [rc=1])
612 if test $rc -ne 0; then :
615 if test "x$enable_linux_builtin" != xyes; then
616 SPL_CHECK_SYMBOL_EXPORT([$3], [$4], [rc=0], [rc=1])
618 if test $rc -ne 0; then :
627 dnl # SPL_CHECK_SYMBOL_HEADER
628 dnl # check if a symbol prototype is defined in listed headers.
630 AC_DEFUN([SPL_CHECK_SYMBOL_HEADER], [
631 AC_MSG_CHECKING([whether symbol $1 exists in header])
634 grep -q "$2" "$LINUX/$file" 2>/dev/null
636 if test $rc -eq 0; then
641 if test $header -eq 0; then
651 dnl # SPL_CHECK_HEADER
652 dnl # check whether header exists and define HAVE_$2_HEADER
654 AC_DEFUN([SPL_CHECK_HEADER],
655 [AC_MSG_CHECKING([whether header $1 exists])
656 SPL_LINUX_TRY_COMPILE([
661 AC_DEFINE(HAVE_$2_HEADER, 1, [$1 exists])
671 dnl # Basic toolchain sanity check. Verify that kernel modules can
672 dnl # be built and which symbols can be used.
674 AC_DEFUN([SPL_AC_TEST_MODULE],
675 [AC_MSG_CHECKING([whether modules can be built])
676 SPL_LINUX_TRY_COMPILE([],[],[
680 if test "x$enable_linux_builtin" != xyes; then
681 AC_MSG_ERROR([*** Unable to build an empty module.])
684 *** Unable to build an empty module.
685 *** Please run 'make scripts' inside the kernel source tree.])
689 AS_IF([test "x$cross_compiling" != xyes], [
692 #include "$LINUX/include/linux/license.h"
694 return !license_is_gpl_compatible(
695 "$SPL_META_LICENSE");
698 AC_DEFINE([SPL_IS_GPL_COMPATIBLE], [1],
699 [Define to 1 if GPL-only symbols can be used])
706 dnl # Use the atomic implemenation based on global spinlocks. This
707 dnl # should only be needed by 32-bit kernels which do not provide
708 dnl # the atomic64_* API. It may be optionally enabled as a fallback
709 dnl # if problems are observed with the direct mapping to the native
710 dnl # Linux atomic operations. You may not disable atomic spinlocks
711 dnl # if you kernel does not an atomic64_* API.
713 AC_DEFUN([SPL_AC_ATOMIC_SPINLOCK], [
714 AC_ARG_ENABLE([atomic-spinlocks],
715 [AS_HELP_STRING([--enable-atomic-spinlocks],
716 [Atomic types use spinlocks @<:@default=check@:>@])],
718 [enable_atomic_spinlocks=check])
720 SPL_LINUX_TRY_COMPILE([
721 #include <linux/fs.h>
723 atomic64_t *ptr __attribute__ ((unused));
726 AC_DEFINE(HAVE_ATOMIC64_T, 1,
727 [kernel defines atomic64_t])
732 AS_IF([test "x$enable_atomic_spinlocks" = xcheck], [
733 AS_IF([test "x$have_atomic64_t" = xyes], [
734 enable_atomic_spinlocks=no
736 enable_atomic_spinlocks=yes
740 AS_IF([test "x$enable_atomic_spinlocks" = xyes], [
741 AC_DEFINE([ATOMIC_SPINLOCK], [1],
742 [Atomic types use spinlocks])
744 AS_IF([test "x$have_atomic64_t" = xno], [
746 [--disable-atomic-spinlocks given but required atomic64 support is unavailable])
750 AC_MSG_CHECKING([whether atomic types use spinlocks])
751 AC_MSG_RESULT([$enable_atomic_spinlocks])
753 AC_MSG_CHECKING([whether kernel defines atomic64_t])
754 AC_MSG_RESULT([$have_atomic64_t])