],[],[],[ext4_free_blocks])
])
AC_DEFUN([LB_EXT_FREE_BLOCKS_WITH_BUFFER_HEAD], [
-AC_MSG_CHECKING([if 'ext4_free_blocks' needs 'struct buffer_head'])
-LB2_LINUX_TEST_RESULT([ext4_free_blocks_with_buffer_head], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'ext4_free_blocks' needs 'struct buffer_head'],
+ [ext4_free_blocks_with_buffer_head], [
AC_DEFINE(HAVE_EXT_FREE_BLOCK_WITH_BUFFER_HEAD, 1,
[ext4_free_blocks do not require struct buffer_head])
])
],[],[],[__ext4_journal_start_sb])
])
AC_DEFUN([LB_EXT4_JOURNAL_START_3ARGS], [
- AC_MSG_CHECKING([if ext4_journal_start takes 3 arguments])
- LB2_LINUX_TEST_RESULT([ext4_journal_start], [
+ LB2_MSG_LINUX_TEST_RESULT([if ext4_journal_start takes 3 arguments],
+ [ext4_journal_start], [
AC_DEFINE(JOURNAL_START_HAS_3ARGS, 1,
[ext4_journal_start takes 3 arguments])
])
],[],[],[ext4_bread])
])
AC_DEFUN([LB_EXT4_BREAD_4ARGS], [
- AC_MSG_CHECKING([if ext4_bread takes 4 arguments])
- LB2_LINUX_TEST_RESULT([ext4_bread], [
+ LB2_MSG_LINUX_TEST_RESULT([if ext4_bread takes 4 arguments],
+ [ext4_bread], [
AC_DEFINE(HAVE_EXT4_BREAD_4ARGS, 1,
[ext4_bread takes 4 arguments])
])
])
])
AC_DEFUN([LB_EXT4_HAVE_INFO_DQUOT], [
- AC_MSG_CHECKING([if i_dquot is in ext4_inode_info])
- LB2_LINUX_TEST_RESULT([ext4_info_dquot], [
+ LB2_MSG_LINUX_TEST_RESULT([if i_dquot is in ext4_inode_info],
+ [ext4_info_dquot], [
AC_DEFINE(HAVE_EXT4_INFO_DQUOT, 1,
[i_dquot is in ext4_inode_info])
])
])
])
AC_DEFUN([LB_EXT4_HAVE_I_CRYPT_INFO], [
- AC_MSG_CHECKING([if i_crypt_info is in ext4_inode_info])
- LB2_LINUX_TEST_RESULT([ext4_i_crypt_info], [
+ LB2_MSG_LINUX_TEST_RESULT([if i_crypt_info is in ext4_inode_info],
+ [ext4_i_crypt_info], [
AC_DEFINE(CONFIG_LDISKFS_FS_ENCRYPTION, 1,
[enable encryption for ldiskfs])
test_have_i_crypt_info=yes
],[-Werror],[],[__ext4_journal_ensure_credits])
])
AC_DEFUN([LB_LDISKFS_JOURNAL_ENSURE_CREDITS], [
- AC_MSG_CHECKING([if 'ext4_journal_ensure_credits' exists])
- LB2_LINUX_TEST_RESULT([ext4_journal_ensure_credits], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'ext4_journal_ensure_credits' exists],
+ [ext4_journal_ensure_credits], [
AC_DEFINE(HAVE_LDISKFS_JOURNAL_ENSURE_CREDITS, 1,
['ext4_journal_ensure_credits' exists])
])
],[-Werror])
])
AC_DEFUN([LB_LDISKFS_IGET_HAS_FLAGS_ARG], [
- AC_MSG_CHECKING([if ldiskfs_iget takes a flags argument])
- LB2_LINUX_TEST_RESULT([ext4_iget_3args], [
+ LB2_MSG_LINUX_TEST_RESULT([if ldiskfs_iget takes a flags argument],
+ [ext4_iget_3args], [
AC_DEFINE(HAVE_LDISKFS_IGET_WITH_FLAGS, 1,
[if ldiskfs_iget takes a flags argument])
])
],[-Werror])
])
AC_DEFUN([LB_LDISKFS_FIND_ENTRY_LOCKED_EXISTS], [
- AC_MSG_CHECKING([if __ldiskfs_find_entry is available])
- LB2_LINUX_TEST_RESULT([ldiskfs_find_entry_locked], [
+ LB2_MSG_LINUX_TEST_RESULT([if __ldiskfs_find_entry is available],
+ [ldiskfs_find_entry_locked], [
AC_DEFINE(HAVE___LDISKFS_FIND_ENTRY, 1,
[if __ldiskfs_find_entry is available])
])
],[-Werror],[],[ext4fs_dirhash])
])
AC_DEFUN([LB_LDISKFSFS_DIRHASH_WANTS_DIR], [
- AC_MSG_CHECKING([if ldiskfsfs_dirhash takes an inode argument])
- LB2_LINUX_TEST_RESULT([ext4fs_dirhash], [
+ LB2_MSG_LINUX_TEST_RESULT([if ldiskfsfs_dirhash takes an inode argument],
+ [ext4fs_dirhash], [
AC_DEFINE(HAVE_LDISKFSFS_DIRHASH_WITH_DIR, 1,
[if ldiskfsfs_dirhash takes an inode argument])
])
],[-Werror])
])
AC_DEFUN([LB_JBD2_H_TOTAL_CREDITS], [
- AC_MSG_CHECKING([if struct jbd2_journal_handle has h_total_credits member])
- LB2_LINUX_TEST_RESULT([handle_t_h_revoke_credits], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct jbd2_journal_handle has h_total_credits member],
+ [handle_t_h_revoke_credits], [
AC_DEFINE(HAVE_JOURNAL_TOTAL_CREDITS, 1,
[struct jbd2_journal_handle has h_total_credits member])
])
],[-Werror],[],[])
])
AC_DEFUN([LB_JBD2_JOURNAL_GET_MAX_TXN_BUFS], [
- AC_MSG_CHECKING([if jbd2_journal_get_max_txn_bufs is available])
- LB2_LINUX_TEST_RESULT([jbd2_journal_get_max_txn_bufs], [
+ LB2_MSG_LINUX_TEST_RESULT([if jbd2_journal_get_max_txn_bufs is available],
+ [jbd2_journal_get_max_txn_bufs], [
AC_DEFINE(HAVE_JBD2_JOURNAL_GET_MAX_TXN_BUFS, 1,
[if jbd2_journal_get_max_txn_bufs is available])
])
])
#
-# LB2_LINUX_TEST_RESULT
+# LB2_MSG_LINUX_TEST_RESULT
#
-# $1 - *unique* name matching the LB2_LINUX_TEST_SRC macro
-# $2 - run on success (valid .ko generated)
-# $3 - run on failure (unable to compile)
-# $4 - compile only
+# $1 - Message
+# $2 - *unique* name matching the LB2_LINUX_TEST_SRC macro
+# $3 - run on success (valid .ko generated)
+# $4 - run on failure (unable to compile)
+# $5 - compile only
#
-AC_DEFUN([LB2_LINUX_TEST_RESULT],[
+AC_DEFUN([LB2_MSG_LINUX_TEST_RESULT],[
TEST_DIR=${TEST_DIR:-${ac_pwd}/_lpb}
- AS_VAR_PUSHDEF([lb_test], [lb_cv_test_$1])
+ AS_VAR_PUSHDEF([lb_test], [lb_cv_test_$2])
D="$(realpath ${TEST_DIR})"
- T=${D}/$1_pc
- O=${T}/$1_pc
+ T=${D}/$2_pc
+ O=${T}/$2_pc
AS_IF([test -d ${T}], [
# test source exists, was the compile test run?
AS_IF(AS_VAR_TEST_SET(lb_test), [], [
],[
# test source does not exist:
AC_MSG_ERROR([
-*** No matching source for the "$1" test, check that
+*** No matching source for the "$2" test, check that
*** both the test source and result macros refer to the same name.
])
])
AS_IF(AS_VAR_TEST_SET(lb_test), [], [
# Fail if the compile was not done.
AS_IF([test -f ${O}.tested], [],
- [AC_MSG_ERROR([*** Compile test for $1 was not run.])])
+ [AC_MSG_ERROR([*** Compile test for $2 was not run.])])
# Default is to expect only the <module>.o be generated.
NEED_KO=0
# Require the <module>.ko file when "module" is passed
- AS_IF([test "X'$4'" == "X'module'"], [NEED_KO=1])
+ AS_IF([test "X'$5'" == "X'module'"], [NEED_KO=1])
# If test was compiled and if we got an object ...
AS_IF([test ${NEED_KO} -eq 0], [AS_IF([test ! -f ${O}.ko], [
AS_IF([test -f ${O}.o], [touch ${O}.ko])])])
])
# key is valid. Cache should be valid, set the variable
- AC_CACHE_CHECK([for $1], lb_test,
+ AC_CACHE_CHECK([$1], lb_test,
AS_IF([test -f ${O}.ko],
AS_VAR_SET([lb_test], [yes]),
AS_VAR_SET([lb_test], [no])))
# Read the variable and run the caller's actions for yes (arg2) or no (arg3)
- AS_VAR_IF([lb_test], [yes], $2, $3)
+ AS_VAR_IF([lb_test], [yes], $3, $4)
AS_VAR_POPDEF([lb_test])
+]) # LB3_LINUX_TEST_RESULT
+
+#
+# LB2_LINUX_TEST_RESULT
+#
+# $1 - *unique* name matching the LB2_LINUX_TEST_SRC macro
+# $2 - run on success (valid .ko generated)
+# $3 - run on failure (unable to compile)
+# $4 - compile only
+#
+AC_DEFUN([LB2_LINUX_TEST_RESULT],[
+ LB2_MSG_LINUX_TEST_RESULT([for $1], [$1], [$2], [$3], [$4])
]) # LB2_LINUX_TEST_RESULT
#
# $3 - do 'no'
#
AC_DEFUN([LB2_TEST_CHECK_CONFIG], [
- AC_MSG_CHECKING([if Linux kernel was built with CONFIG_$1])
- LB2_LINUX_TEST_RESULT([config_$1], [
+ LB2_MSG_LINUX_TEST_RESULT([if Linux kernel was built with CONFIG_$1],
+ [config_$1], [
$2
],[
$3
# $3 - do 'no'
#
AC_DEFUN([LB2_TEST_CHECK_CONFIG_IM], [
- AC_MSG_CHECKING([if Linux kernel enabled CONFIG_$1 as built-in or module])
- LB2_LINUX_TEST_RESULT([config_im_$1], [
+ LB2_MSG_LINUX_TEST_RESULT([if Linux kernel enabled CONFIG_$1 as built-in or module],
+ [config_im_$1], [
$2
],[
$3
# $3 - On Failure
#
AC_DEFUN([LB2_CHECK_LINUX_HEADER_RESULT], [
- AC_MSG_CHECKING([for linux header $1])
UNIQUE_ID=$(echo $1 | tr /. __)
- LB2_LINUX_TEST_RESULT([${UNIQUE_ID}], [$2], [$3])
+ LB2_MSG_LINUX_TEST_RESULT([for linux header $1], [${UNIQUE_ID}],
+ [$2], [$3])
])
])
])
AC_DEFUN([LIBCFS_KTIME_GET_TS64], [
- AC_MSG_CHECKING([does function 'ktime_get_ts64' exist])
- LB2_LINUX_TEST_RESULT([ktime_get_ts64], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'ktime_get_ts64' exist],
+ [ktime_get_ts64], [
AC_DEFINE(HAVE_KTIME_GET_TS64, 1,
['ktime_get_ts64' is available])
])
])
])
AC_DEFUN([LIBCFS_PREPARE_TO_WAIT_EVENT],[
- AC_MSG_CHECKING([does function 'prepare_to_wait_event' exist])
- LB2_LINUX_TEST_RESULT([prepare_to_wait_event], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'prepare_to_wait_event' exist],
+ [prepare_to_wait_event], [
AC_DEFINE(HAVE_PREPARE_TO_WAIT_EVENT, 1,
['prepare_to_wait_event' is available])
])
])
])
AC_DEFUN([LIBCFS_KERNEL_PARAM_OPS],[
- AC_MSG_CHECKING([does 'struct kernel_param_ops' exist])
- LB2_LINUX_TEST_RESULT([kernel_param_ops], [
+ LB2_MSG_LINUX_TEST_RESULT([does 'struct kernel_param_ops' exist],
+ [kernel_param_ops], [
AC_DEFINE(HAVE_KERNEL_PARAM_OPS, 1,
['struct kernel_param_ops' is available])
])
])
])
AC_DEFUN([LIBCFS_KTIME_ADD],[
- AC_MSG_CHECKING([does function 'ktime_add' exist])
- LB2_LINUX_TEST_RESULT([ktime_add], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'ktime_add' exist],
+ [ktime_add], [
AC_DEFINE(HAVE_KTIME_ADD, 1, [ktime_add is available])
])
]) # LIBCFS_KTIME_ADD
])
])
AC_DEFUN([LIBCFS_KTIME_AFTER],[
- AC_MSG_CHECKING([does function 'ktime_after' exist])
- LB2_LINUX_TEST_RESULT([ktime_after], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'ktime_after' exist],
+ [ktime_after], [
AC_DEFINE(HAVE_KTIME_AFTER, 1, [ktime_after is available])
])
]) # LIBCFS_KTIME_AFTER
])
])
AC_DEFUN([LIBCFS_KTIME_BEFORE],[
- AC_MSG_CHECKING([does function 'ktime_before' exist])
- LB2_LINUX_TEST_RESULT([ktime_before], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'ktime_before' exist],
+ [ktime_before], [
AC_DEFINE(HAVE_KTIME_BEFORE, 1, [ktime_before is available])
])
]) # LIBCFS_KTIME_BEFORE
])
])
AC_DEFUN([LIBCFS_KTIME_COMPARE],[
- AC_MSG_CHECKING([does function 'ktime_compare' exist])
- LB2_LINUX_TEST_RESULT([ktime_compare], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'ktime_compare' exist],
+ [ktime_compare], [
AC_DEFINE(HAVE_KTIME_COMPARE, 1,
[ktime_compare is available])
])
])
])
AC_DEFUN([LIBCFS_SHRINKER_COUNT],[
- AC_MSG_CHECKING([shrinker has 'count_objects'])
- LB2_LINUX_TEST_RESULT([shrinker_count_objects], [
+ LB2_MSG_LINUX_TEST_RESULT([shrinker has 'count_objects'],
+ [shrinker_count_objects], [
AC_DEFINE(HAVE_SHRINKER_COUNT, 1,
[shrinker has count_objects member])
])
])
])
AC_DEFUN([LIBCFS_MATCH_WILDCARD],[
- AC_MSG_CHECKING([does function 'match_wildcard' exist])
- LB2_LINUX_TEST_RESULT([match_wildcard], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'match_wildcard' exist],
+ [match_wildcard], [
AC_DEFINE(HAVE_MATCH_WILDCARD, 1,
[match_wildcard() is available])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_HAVE_MAPPING_AS_EXITING_FLAG], [
- AC_MSG_CHECKING([if enum mapping_flags has AS_EXITING flag])
- LB2_LINUX_TEST_RESULT([mapping_exiting_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if enum mapping_flags has AS_EXITING flag],
+ [mapping_exiting_exists], [
AC_DEFINE(HAVE_MAPPING_AS_EXITING_FLAG, 1,
[enum mapping_flags has AS_EXITING flag])
])
[-Werror])
])
AC_DEFUN([LIBCFS_IOV_ITER_HAS_TYPE], [
- AC_MSG_CHECKING([if iov_iter has member type])
- LB2_LINUX_TEST_RESULT([iov_iter_has_type_member], [
+ LB2_MSG_LINUX_TEST_RESULT([if iov_iter has member type],
+ [iov_iter_has_type_member], [
AC_DEFINE(HAVE_IOV_ITER_HAS_TYPE_MEMBER, 1,
[if iov_iter has member type])
])
])
])
AC_DEFUN([LIBCFS_HAVE_NS_TO_TIMESPEC64],[
- AC_MSG_CHECKING([does 'ns_to_timespec64()' exist])
- LB2_LINUX_TEST_RESULT([kernel_old_timeval], [
+ LB2_MSG_LINUX_TEST_RESULT([does 'ns_to_timespec64()' exist],
+ [kernel_old_timeval], [
AC_DEFINE(HAVE_NS_TO_TIMESPEC64, 1,
[ns_to_timespec64() is available])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_HAVE_GLOB],[
- AC_MSG_CHECKING([does 'glob_match()' exist])
- LB2_LINUX_TEST_RESULT([glob_match], [
+ LB2_MSG_LINUX_TEST_RESULT([does 'glob_match()' exist],
+ [glob_match], [
AC_DEFINE(HAVE_GLOB, 1,
[glob_match() is available])
])
])
])
AC_DEFUN([LIBCFS_HLIST_ADD_AFTER],[
- AC_MSG_CHECKING([does function 'hlist_add_after' exist])
- LB2_LINUX_TEST_RESULT([hlist_add_after], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'hlist_add_after' exist],
+ [hlist_add_after], [
AC_DEFINE(HAVE_HLIST_ADD_AFTER, 1,
[hlist_add_after is available])
])
])
])
AC_DEFUN([LIBCFS_TIMESPEC64],[
- AC_MSG_CHECKING([does 'struct timespec64' exist])
- LB2_LINUX_TEST_RESULT([timespec64], [
+ LB2_MSG_LINUX_TEST_RESULT([does 'struct timespec64' exist],
+ [timespec64], [
AC_DEFINE(HAVE_TIMESPEC64, 1,
['struct timespec64' is available])
])
])
])
AC_DEFUN([LIBCFS_KTIME_GET_REAL_TS64],[
- AC_MSG_CHECKING([does function 'ktime_get_real_ts64' exist])
- LB2_LINUX_TEST_RESULT([ktime_get_real_ts64], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'ktime_get_real_ts64' exist],
+ [ktime_get_real_ts64], [
AC_DEFINE(HAVE_KTIME_GET_REAL_TS64, 1,
['ktime_get_real_ts64' is available])
])
])
])
AC_DEFUN([LIBCFS_KTIME_GET_REAL_SECONDS],[
- AC_MSG_CHECKING([does function 'ktime_get_real_ts64' exist])
- LB2_LINUX_TEST_RESULT([ktime_get_real_seconds], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'ktime_get_real_ts64' exist],
+ [ktime_get_real_seconds], [
AC_DEFINE(HAVE_KTIME_GET_REAL_SECONDS, 1,
['ktime_get_real_seconds' is available])
])
])
])
AC_DEFUN([LIBCFS_KTIME_GET_NS],[
- AC_MSG_CHECKING([does function 'ktime_get_ns' exist])
- LB2_LINUX_TEST_RESULT([ktime_get_ns], [],[
+ LB2_MSG_LINUX_TEST_RESULT([does function 'ktime_get_ns' exist],
+ [ktime_get_ns], [],[
AC_DEFINE(NEED_KTIME_GET_NS, 1,
['ktime_get_ns' is not available])
])
])
])
AC_DEFUN([LIBCFS_KTIME_GET_REAL_NS],[
- AC_MSG_CHECKING([does function 'ktime_get_real_ns' exist])
- LB2_LINUX_TEST_RESULT([ktime_get_real_ns], [],[
+ LB2_MSG_LINUX_TEST_RESULT([does function 'ktime_get_real_ns' exist],
+ [ktime_get_real_ns], [],[
AC_DEFINE(NEED_KTIME_GET_REAL_NS, 1,
['ktime_get_real_ns' is not available])
])
])
])
AC_DEFUN([LIBCFS_KTIME_TO_TIMESPEC64],[
- AC_MSG_CHECKING([does function 'ktime_to_timespec64' exist])
- LB2_LINUX_TEST_RESULT([ktime_to_timespec64], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'ktime_to_timespec64' exist],
+ [ktime_to_timespec64], [
AC_DEFINE(HAVE_KTIME_TO_TIMESPEC64, 1,
['ktime_to_timespec64' is available])
])
])
])
AC_DEFUN([LIBCFS_TIMESPEC64_SUB],[
- AC_MSG_CHECKING([does function 'timespec64_sub' exist])
- LB2_LINUX_TEST_RESULT([timespec64_sub], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'timespec64_sub' exist],
+ [timespec64_sub], [
AC_DEFINE(HAVE_TIMESPEC64_SUB, 1,
['timespec64_sub' is available])
])
])
])
AC_DEFUN([LIBCFS_TIMESPEC64_TO_KTIME],[
- AC_MSG_CHECKING([does function 'timespec64_to_ktime' exist])
- LB2_LINUX_TEST_RESULT([timespec64_to_ktime], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'timespec64_to_ktime' exist],
+ [timespec64_to_ktime], [
AC_DEFINE(HAVE_TIMESPEC64_TO_KTIME, 1,
['timespec64_to_ktime' is available])
])
])
])
AC_DEFUN([LIBCFS_KTIME_GET_SECONDS],[
- AC_MSG_CHECKING([does function 'ktime_get_seconds' exist])
- LB2_LINUX_TEST_RESULT([ktime_get_seconds], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'ktime_get_seconds' exist],
+ [ktime_get_seconds], [
AC_DEFINE(HAVE_KTIME_GET_SECONDS, 1,
['ktime_get_seconds' is available])
])
])
])
AC_DEFUN([LIBCFS_WAIT_WOKEN],[
- AC_MSG_CHECKING([does function 'wait_woken' exist])
- LB2_LINUX_TEST_RESULT([wait_woken], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'wait_woken' exist],
+ [wait_woken], [
AC_DEFINE(HAVE_WAIT_WOKEN, 1,
['wait_woken, is available'])
])
])
])
AC_DEFUN([LIBCFS_KTIME_MS_DELTA],[
- AC_MSG_CHECKING([does function 'ktime_ms_delta' exist])
- LB2_LINUX_TEST_RESULT([ktime_ms_delta], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'ktime_ms_delta' exist],
+ [ktime_ms_delta], [
AC_DEFINE(HAVE_KTIME_MS_DELTA, 1,
['ktime_ms_delta' is available])
])
])
])
AC_DEFUN([LIBCFS_KERNEL_PARAM_LOCK],[
- AC_MSG_CHECKING([does function 'kernel_param_[un]lock' exist])
- LB2_LINUX_TEST_RESULT([kernel_param_lock], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'kernel_param_[un]lock' exist],
+ [kernel_param_lock], [
AC_DEFINE(HAVE_KERNEL_PARAM_LOCK, 1,
['kernel_param_[un]lock' is available])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_STRSCPY_EXISTS], [
- AC_MSG_CHECKING([if kernel strscpy is available])
- LB2_LINUX_TEST_RESULT([strscpy_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if kernel strscpy is available],
+ [strscpy_exists], [
AC_DEFINE(HAVE_STRSCPY, 1,
[kernel strscpy is available])
])
])
])
AC_DEFUN([LIBCFS_HAVE_TOPOLOGY_SIBLING_CPUMASK],[
- AC_MSG_CHECKING([does function 'topology_sibling_cpumask' exist])
- LB2_LINUX_TEST_RESULT([topology_sibling_cpumask], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'topology_sibling_cpumask' exist],
+ [topology_sibling_cpumask], [
AC_DEFINE(HAVE_TOPOLOGY_SIBLING_CPUMASK, 1,
[topology_sibling_cpumask is available])
])
])
])
AC_DEFUN([LIBCFS_KSTRTOBOOL_FROM_USER], [
- AC_MSG_CHECKING([if Linux kernel has 'kstrtobool_from_user'])
- LB2_LINUX_TEST_RESULT([kstrtobool_from_user], [
+ LB2_MSG_LINUX_TEST_RESULT([if Linux kernel has 'kstrtobool_from_user'],
+ [kstrtobool_from_user], [
AC_DEFINE(HAVE_KSTRTOBOOL_FROM_USER, 1,
[kernel has kstrtobool_from_user])
])
],[])
])
AC_DEFUN([LIBCFS_NETLINK_CALLBACK_START], [
- AC_MSG_CHECKING([if struct genl_ops has start callback])
- LB2_LINUX_TEST_RESULT([cb_start], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct genl_ops has start callback],
+ [cb_start], [
AC_DEFINE(HAVE_NETLINK_CALLBACK_START, 1,
[struct genl_ops has 'start' callback])
])
])
])
AC_DEFUN([LIBCFS_CRYPTO_HASH_HELPERS], [
- AC_MSG_CHECKING([does crypto hash helper functions exist])
- LB2_LINUX_TEST_RESULT([crypto_hash_helpers], [
+ LB2_MSG_LINUX_TEST_RESULT([does crypto hash helper functions exist],
+ [crypto_hash_helpers], [
AC_DEFINE(HAVE_CRYPTO_HASH_HELPERS, 1,
[crypto hash helper functions are available])
])
])
])
AC_DEFUN([LIBCFS_RHASHTABLE_REPLACE], [
- AC_MSG_CHECKING([if 'rhashtable_replace_fast' exists])
- LB2_LINUX_TEST_RESULT([rhashtable_replace_fast], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'rhashtable_replace_fast' exists],
+ [rhashtable_replace_fast], [
AC_DEFINE(HAVE_RHASHTABLE_REPLACE, 1,
[rhashtable_replace_fast() is available])
])
])
])
AC_DEFUN([LIBCFS_BROKEN_HASH_64], [
- AC_MSG_CHECKING([kernel has fixed hash_64()])
- LB2_LINUX_TEST_RESULT([broken_hash_64], [
+ LB2_MSG_LINUX_TEST_RESULT([kernel has fixed hash_64()],
+ [broken_hash_64], [
AC_DEFINE(HAVE_BROKEN_HASH_64, 1, [kernel hash_64() is broken])
])
]) # LIBCFS_BROKEN_HASH_64
])
])
AC_DEFUN([LIBCFS_STACKTRACE_OPS_ADDRESS_RETURN_INT], [
- AC_MSG_CHECKING([if 'struct stacktrace_ops' address function returns an int])
- LB2_LINUX_TEST_RESULT([stacktrace_ops_address_return_int], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct stacktrace_ops' address function returns an int],
+ [stacktrace_ops_address_return_int], [
AC_DEFINE(STACKTRACE_OPS_ADDRESS_RETURN_INT, 1,
['struct stacktrace_ops' address function returns an int])
])
])
])
AC_DEFUN([LIBCFS_GET_USER_PAGES_6ARG], [
- AC_MSG_CHECKING([if 'get_user_pages()' takes 6 arguments])
- LB2_LINUX_TEST_RESULT([get_user_pages_6arg], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'get_user_pages()' takes 6 arguments],
+ [get_user_pages_6arg], [
AC_DEFINE(HAVE_GET_USER_PAGES_6ARG, 1,
[get_user_pages takes 6 arguments])
])
[-Werror])
])
AC_DEFUN([LIBCFS_RHASHTABLE_INSERT_FAST], [
- AC_MSG_CHECKING([if internal '__rhashtable_insert_fast()' returns int])
- LB2_LINUX_TEST_RESULT([rhashtable_insert_fast], [
+ LB2_MSG_LINUX_TEST_RESULT([if internal '__rhashtable_insert_fast()' returns int],
+ [rhashtable_insert_fast], [
AC_DEFINE(HAVE_HASHTABLE_INSERT_FAST_RETURN_INT, 1,
['__rhashtable_insert_fast()' returns int])
])
])
])
AC_DEFUN([LIBCFS_RHASHTABLE_WALK_INIT_3ARG], [
- AC_MSG_CHECKING([if 'rhashtable_walk_init' has 3 args])
- LB2_LINUX_TEST_RESULT([rhashtable_walk_init], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'rhashtable_walk_init' has 3 args],
+ [rhashtable_walk_init], [
AC_DEFINE(HAVE_3ARG_RHASHTABLE_WALK_INIT, 1,
[rhashtable_walk_init() has 3 args])
])
])
])
AC_DEFUN([LIBCFS_RHASHTABLE_LOOKUP], [
- AC_MSG_CHECKING([if 'rhashtable_lookup' exist])
- LB2_LINUX_TEST_RESULT([rhashtable_lookup], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'rhashtable_lookup' exist],
+ [rhashtable_lookup], [
AC_DEFINE(HAVE_RHASHTABLE_LOOKUP, 1,
[rhashtable_lookup() is available])
])
])
])
AC_DEFUN([LIBCFS_RHLTABLE], [
- AC_MSG_CHECKING([does 'struct rhltable' exist])
- LB2_LINUX_TEST_RESULT([rhtable], [
+ LB2_MSG_LINUX_TEST_RESULT([does 'struct rhltable' exist],
+ [rhtable], [
AC_DEFINE(HAVE_RHLTABLE, 1, [struct rhltable exist])
])
]) # LIBCFS_RHLTABLE
])
])
AC_DEFUN([LIBCFS_STACKTRACE_OPS], [
-AC_MSG_CHECKING([if 'struct stacktrace_ops' exists])
- LB2_LINUX_TEST_RESULT([stacktrace_ops], [
+LB2_MSG_LINUX_TEST_RESULT([if 'struct stacktrace_ops' exists],
+ [stacktrace_ops], [
AC_DEFINE(HAVE_STACKTRACE_OPS, 1,
[struct stacktrace_ops exists])
])
])
])
AC_DEFUN([LIBCFS_RHASHTABLE_WALK_ENTER], [
- AC_MSG_CHECKING([if 'rhashtable_walk_enter' exists])
- LB2_LINUX_TEST_RESULT([rhashtable_walk_enter], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'rhashtable_walk_enter' exists],
+ [rhashtable_walk_enter], [
AC_DEFINE(HAVE_RHASHTABLE_WALK_ENTER, 1,
[rhashtable_walk_enter() is available])
])
])
])
AC_DEFUN([LIBCFS_GET_USER_PAGES_GUP_FLAGS], [
- AC_MSG_CHECKING([if 'get_user_pages()' takes gup_flags in arguments])
- LB2_LINUX_TEST_RESULT([get_user_pages_gup_flags], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'get_user_pages()' takes gup_flags in arguments],
+ [get_user_pages_gup_flags], [
AC_DEFINE(HAVE_GET_USER_PAGES_GUP_FLAGS, 1,
[get_user_pages takes gup_flags in arguments])
])
])
])
AC_DEFUN([LIBCFS_HOTPLUG_STATE_MACHINE], [
- AC_MSG_CHECKING([if libcfs supports CPU hotplug state machine])
- LB2_LINUX_TEST_RESULT([cpu_hotplug_state_machine], [
+ LB2_MSG_LINUX_TEST_RESULT([if libcfs supports CPU hotplug state machine],
+ [cpu_hotplug_state_machine], [
AC_DEFINE(HAVE_HOTPLUG_STATE_MACHINE, 1,
[hotplug state machine is supported])
])
])
])
AC_DEFUN([LIBCFS_MEMALLOC_NORECLAIM], [
- AC_MSG_CHECKING([if memalloc_noreclaim_{save,restore} exist])
- LB2_LINUX_TEST_RESULT([memalloc_noreclaim], [
+ LB2_MSG_LINUX_TEST_RESULT([if memalloc_noreclaim_{save,restore} exist],
+ [memalloc_noreclaim], [
AC_DEFINE(HAVE_MEMALLOC_RECLAIM, 1,
[memalloc_noreclaim_{save,restore}() is supported])
])
])
])
AC_DEFUN([LIBCFS_KREF_READ], [
- AC_MSG_CHECKING([if 'kref_read' exists])
- LB2_LINUX_TEST_RESULT([kref_read], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'kref_read' exists],
+ [kref_read], [
AC_DEFINE(HAVE_KREF_READ, 1, [kref_read() is available])
])
]) # LIBCFS_KREF_READ
])
])
AC_DEFUN([LIBCFS_RHT_BUCKET_VAR], [
- AC_MSG_CHECKING([if 'rht_bucket_var' exists])
- LB2_LINUX_TEST_RESULT([rht_bucket_var], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'rht_bucket_var' exists],
+ [rht_bucket_var], [
AC_DEFINE(HAVE_RHT_BUCKET_VAR, 1,
[rht_bucket_var() is available])
])
])
])
AC_DEFUN([LIBCFS_NL_EXT_ACK], [
- AC_MSG_CHECKING([if Netlink supports netlink_ext_ack])
- LB2_LINUX_TEST_RESULT([netlink_ext_ack], [
+ LB2_MSG_LINUX_TEST_RESULT([if Netlink supports netlink_ext_ack],
+ [netlink_ext_ack], [
AC_DEFINE(HAVE_NL_PARSE_WITH_EXT_ACK, 1,
[netlink_ext_ack is an argument to nla_parse type function])
])
])
])
AC_DEFUN([LIBCFS_RHASHTABLE_LOOKUP_GET_INSERT_FAST], [
- AC_MSG_CHECKING([if 'rhashtable_lookup_get_insert_fast' exist])
- LB2_LINUX_TEST_RESULT([rhashtable_lookup_get_insert_fast], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'rhashtable_lookup_get_insert_fast' exist],
+ [rhashtable_lookup_get_insert_fast], [
AC_DEFINE(HAVE_RHASHTABLE_LOOKUP_GET_INSERT_FAST, 1,
[rhashtable_lookup_get_insert_fast() is available])
])
])
])
AC_DEFUN([LIBCFS_CPUS_READ_LOCK], [
- AC_MSG_CHECKING([if 'cpus_read_[un]lock' exist])
- LB2_LINUX_TEST_RESULT([cpu_read_lock], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'cpus_read_[un]lock' exist],
+ [cpu_read_lock], [
AC_DEFINE(HAVE_CPUS_READ_LOCK, 1, ['cpus_read_lock' exist])
])
]) # LIBCFS_CPUS_READ_LOCK
])
])
AC_DEFUN([LIBCFS_WAIT_QUEUE_TASK_LIST_RENAME], [
- AC_MSG_CHECKING([if linux wait_queue_head list_head is named head])
- LB2_LINUX_TEST_RESULT([wait_queue_task_list], [
+ LB2_MSG_LINUX_TEST_RESULT([if linux wait_queue_head list_head is named head],
+ [wait_queue_task_list], [
AC_DEFINE(HAVE_WAIT_QUEUE_ENTRY_LIST, 1,
[linux wait_queue_head_t list_head is name head])
])
])
])
AC_DEFUN([LIBCFS_WAIT_BIT_QUEUE_ENTRY_EXISTS], [
- AC_MSG_CHECKING([if struct wait_bit_queue_entry exists])
- LB2_LINUX_TEST_RESULT([struct_wait_bit_queue_entry_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct wait_bit_queue_entry exists],
+ [struct_wait_bit_queue_entry_exists], [
AC_DEFINE(HAVE_WAIT_BIT_QUEUE_ENTRY, 1,
[if struct wait_bit_queue_entry exists])
])
],[])
])
AC_DEFUN([LIBCFS_NLA_STRDUP], [
- AC_MSG_CHECKING([if 'nla_strdup()' exists])
- LB2_LINUX_TEST_RESULT([nla_strdup], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'nla_strdup()' exists],
+ [nla_strdup], [
AC_DEFINE(HAVE_NLA_STRDUP, 1,
['nla_strdup' is available])
])
])
])
AC_DEFUN([LIBCFS_WAIT_QUEUE_ENTRY], [
- AC_MSG_CHECKING([if 'wait_queue_entry_t' exists])
- LB2_LINUX_TEST_RESULT([wait_queue_entry], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'wait_queue_entry_t' exists],
+ [wait_queue_entry], [
AC_DEFINE(HAVE_WAIT_QUEUE_ENTRY, 1,
['wait_queue_entry_t' is available])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_NEW_KERNEL_WRITE], [
- AC_MSG_CHECKING([if 'kernel_write' matches other read/write helpers])
- LB2_LINUX_TEST_RESULT([kernel_write_match], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'kernel_write' matches other read/write helpers],
+ [kernel_write_match], [
AC_DEFINE(HAVE_NEW_KERNEL_WRITE, 1,
['kernel_write' aligns with read/write helpers])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_MM_TOTALRAM_PAGES_FUNC], [
- AC_MSG_CHECKING([if totalram_pages is a function])
- LB2_LINUX_TEST_RESULT([totalram_pages], [
+ LB2_MSG_LINUX_TEST_RESULT([if totalram_pages is a function],
+ [totalram_pages], [
AC_DEFINE(HAVE_TOTALRAM_PAGES_AS_FUNC, 1,
[if totalram_pages is a function])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_NEW_KERNEL_READ], [
- AC_MSG_CHECKING([if 'kernel_read()' has loff_t *pos as last parameter])
- LB2_LINUX_TEST_RESULT([kernel_read], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'kernel_read()' has loff_t *pos as last parameter],
+ [kernel_read], [
AC_DEFINE(HAVE_KERNEL_READ_LAST_POSP, 1,
[kernel_read() signature ends with loff_t *pos])
])
])
])
AC_DEFUN([LIBCFS_DEFINE_TIMER], [
- AC_MSG_CHECKING([if DEFINE_TIMER takes only 2 arguments])
- LB2_LINUX_TEST_RESULT([define_timer], [
+ LB2_MSG_LINUX_TEST_RESULT([if DEFINE_TIMER takes only 2 arguments],
+ [define_timer], [
AC_DEFINE(HAVE_NEW_DEFINE_TIMER, 1,
[DEFINE_TIMER uses only 2 arguements])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_LOCKDEP_IS_HELD], [
- AC_MSG_CHECKING([if 'lockdep_is_held()' uses const argument])
- LB2_LINUX_TEST_RESULT([lockdep_is_held], [],[
+ LB2_MSG_LINUX_TEST_RESULT([if 'lockdep_is_held()' uses const argument],
+ [lockdep_is_held], [
+ ],[
AC_DEFINE(NEED_LOCKDEP_IS_HELD_DISCARD_CONST, 1,
[lockdep_is_held() argument is const])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_BITMAP_TO_ARR32], [
- AC_MSG_CHECKING([if 'bitmap_to_arr32()' exist])
- LB2_LINUX_TEST_RESULT([bitmap_to_arr32], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'bitmap_to_arr32()' exist],
+ [bitmap_to_arr32], [
AC_DEFINE(HAVE_BITMAP_TO_ARR32, 1,
[bitmap_to_arr32() exist])
])
])
])
AC_DEFUN([LIBCFS_TIMER_SETUP], [
- AC_MSG_CHECKING([if setup_timer has been replaced with timer_setup])
- LB2_LINUX_TEST_RESULT([timer_setup], [
+ LB2_MSG_LINUX_TEST_RESULT([if setup_timer has been replaced with timer_setup],
+ [timer_setup], [
AC_DEFINE(HAVE_TIMER_SETUP, 1,
[timer_setup has replaced setup_timer])
])
],[${WAIT_BIT_H}])
])
AC_DEFUN([LIBCFS_WAIT_VAR_EVENT], [
- AC_MSG_CHECKING([if 'wait_var_event' exist])
- LB2_LINUX_TEST_RESULT([wait_var_event], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'wait_var_event' exist],
+ [wait_var_event], [
AC_DEFINE(HAVE_WAIT_VAR_EVENT, 1,
['wait_var_event' is available])
])
])
])
AC_DEFUN([LIBCFS_BITMAP_ALLOC], [
- AC_MSG_CHECKING([if Linux bitmap memory management exist])
- LB2_LINUX_TEST_RESULT([bitmap_alloc], [
+ LB2_MSG_LINUX_TEST_RESULT([if Linux bitmap memory management exist],
+ [bitmap_alloc], [
AC_DEFINE(HAVE_BITMAP_ALLOC, 1,
[Linux bitmap can be allocated])
])
],[${WAIT_BIT_H}])
])
AC_DEFUN([LIBCFS_CLEAR_AND_WAKE_UP_BIT], [
- AC_MSG_CHECKING([if 'clear_and_wake_up_bit' exist])
- LB2_LINUX_TEST_RESULT([clear_and_wake_up_bit], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'clear_and_wake_up_bit' exist],
+ [clear_and_wake_up_bit], [
AC_DEFINE(HAVE_CLEAR_AND_WAKE_UP_BIT, 1,
['clear_and_wake_up_bit' is available])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_TCP_SOCK_SET_NODELAY], [
- AC_MSG_CHECKING([if 'tcp_sock_set_nodelay()' exists])
- LB2_LINUX_TEST_RESULT([tcp_sock_set_nodelay_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'tcp_sock_set_nodelay()' exists],
+ [tcp_sock_set_nodelay_exists], [
AC_DEFINE(HAVE_TCP_SOCK_SET_NODELAY, 1,
['tcp_sock_set_nodelay()' exists])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_TCP_SOCK_SET_KEEPIDLE], [
- AC_MSG_CHECKING([if 'tcp_sock_set_keepidle()' exists])
- LB2_LINUX_TEST_RESULT([tcp_sock_set_keepidle_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'tcp_sock_set_keepidle()' exists],
+ [tcp_sock_set_keepidle_exists], [
AC_DEFINE(HAVE_TCP_SOCK_SET_KEEPIDLE, 1,
['tcp_sock_set_keepidle()' exists])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_TCP_SOCK_SET_QUICKACK], [
- AC_MSG_CHECKING([if 'tcp_sock_set_quickack()' exists])
- LB2_LINUX_TEST_RESULT([tcp_sock_set_quickack_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'tcp_sock_set_quickack()' exists],
+ [tcp_sock_set_quickack_exists], [
AC_DEFINE(HAVE_TCP_SOCK_SET_QUICKACK, 1,
['tcp_sock_set_quickack()' exists])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_TCP_SOCK_SET_KEEPINTVL], [
- AC_MSG_CHECKING([if 'tcp_sock_set_keepintvl()' exists])
- LB2_LINUX_TEST_RESULT([tcp_sock_set_keepintvl_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'tcp_sock_set_keepintvl()' exists],
+ [tcp_sock_set_keepintvl_exists], [
AC_DEFINE(HAVE_TCP_SOCK_SET_KEEPINTVL, 1,
['tcp_sock_set_keepintvl()' exists])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_TCP_SOCK_SET_KEEPCNT], [
- AC_MSG_CHECKING([if 'tcp_sock_set_keepcnt()' exists])
- LB2_LINUX_TEST_RESULT([tcp_sock_set_keepcnt_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'tcp_sock_set_keepcnt()' exists],
+ [tcp_sock_set_keepcnt_exists], [
AC_DEFINE(HAVE_TCP_SOCK_SET_KEEPCNT, 1,
['tcp_sock_set_keepcnt()' exists])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_XARRAY_SUPPORT], [
- AC_MSG_CHECKING([if page cache uses Xarray])
- LB2_LINUX_TEST_RESULT([xarray_support], [
+ LB2_MSG_LINUX_TEST_RESULT([if page cache uses Xarray],
+ [xarray_support], [
AC_DEFINE(HAVE_XARRAY_SUPPORT, 1,
[kernel Xarray implementation lacks 'xa_is_value'])
])
],[])
])
AC_DEFUN([LIBCFS_NL_DUMP_EXT_ACK], [
- AC_MSG_CHECKING([if Netlink dump handlers support ext_ack])
- LB2_LINUX_TEST_RESULT([netlink_dump_ext_ack], [
+ LB2_MSG_LINUX_TEST_RESULT([if Netlink dump handlers support ext_ack],
+ [netlink_dump_ext_ack], [
AC_DEFINE(HAVE_NL_DUMP_WITH_EXT_ACK, 1,
[netlink_ext_ack is handled for Netlink dump handlers])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_HAVE_IOV_ITER_TYPE], [
- AC_MSG_CHECKING([if iov_iter_type exists])
- LB2_LINUX_TEST_RESULT([macro_iov_iter_type_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if iov_iter_type exists],
+ [macro_iov_iter_type_exists], [
AC_DEFINE(HAVE_IOV_ITER_TYPE, 1,
[if iov_iter_type exists])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_GET_REQUEST_KEY_AUTH], [
- AC_MSG_CHECKING([if get_request_key_auth() is available])
- LB2_LINUX_TEST_RESULT([get_request_key_auth_exported], [
+ LB2_MSG_LINUX_TEST_RESULT([if get_request_key_auth() is available],
+ [get_request_key_auth_exported], [
AC_DEFINE(HAVE_GET_REQUEST_KEY_AUTH, 1,
[get_request_key_auth() is available])
])
])
])
AC_DEFUN([LIBCFS_KOBJ_TYPE_DEFAULT_GROUPS],[
- AC_MSG_CHECKING([does struct kobj_type have 'default_groups' member])
- LB2_LINUX_TEST_RESULT([kobj_type_default_groups], [
+ LB2_MSG_LINUX_TEST_RESULT([does struct kobj_type have 'default_groups' member],
+ [kobj_type_default_groups], [
AC_DEFINE(HAVE_KOBJ_TYPE_DEFAULT_GROUPS, 1,
[struct kobj_type has 'default_groups' member])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_LOOKUP_USER_KEY], [
- AC_MSG_CHECKING([if lookup_user_key() is available])
- LB2_LINUX_TEST_RESULT([lookup_user_key_exported], [
+ LB2_MSG_LINUX_TEST_RESULT([if lookup_user_key() is available],
+ [lookup_user_key_exported], [
AC_DEFINE(HAVE_LOOKUP_USER_KEY, 1,
[lookup_user_key() is available])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_CACHE_DETAIL_WRITERS], [
- AC_MSG_CHECKING([if struct cache_detail has writers])
- LB2_LINUX_TEST_RESULT([cache_detail_writers_atomic], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct cache_detail has writers],
+ [cache_detail_writers_atomic], [
AC_DEFINE(HAVE_CACHE_DETAIL_WRITERS, 1,
[struct cache_detail has writers])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_GENL_DUMPIT_INFO], [
- AC_MSG_CHECKING([if struct genl_dumpit_info has family field])
- LB2_LINUX_TEST_RESULT([genl_dumpit_info], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct genl_dumpit_info has family field],
+ [genl_dumpit_info], [
AC_DEFINE(HAVE_GENL_DUMPIT_INFO, 1,
[struct genl_dumpit_info has family field])
])
],[-Werror])
]) # LIBCFS_SRC_HAVE_PROC_OPS
AC_DEFUN([LIBCFS_HAVE_PROC_OPS], [
- AC_MSG_CHECKING([if struct proc_ops exists])
- LB2_LINUX_TEST_RESULT([proc_ops], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct proc_ops exists],
+ [proc_ops], [
AC_DEFINE(HAVE_PROC_OPS, 1,
[struct proc_ops exists])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_IP6_SET_PREF], [
- AC_MSG_CHECKING([if ip6_sock_set_addr_preferences() exists])
- LB2_LINUX_TEST_RESULT([ip6_set_pref_test], [
+ LB2_MSG_LINUX_TEST_RESULT([if ip6_sock_set_addr_preferences() exists],
+ [ip6_set_pref_test], [
AC_DEFINE(HAVE_IP6_SET_PREF, 1,
[if ip6_sock_set_addr_preferences exists])
])
],[])
])
AC_DEFUN([LIBCFS_VMALLOC_2ARGS], [
- AC_MSG_CHECKING([if __vmalloc has 2 args])
- LB2_LINUX_TEST_RESULT([vmalloc_2args], [
+ LB2_MSG_LINUX_TEST_RESULT([if __vmalloc has 2 args],
+ [vmalloc_2args], [
AC_DEFINE(HAVE_VMALLOC_2ARGS, 1,
[__vmalloc only takes 2 args.])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_HAVE_NR_UNSTABLE_NFS], [
- AC_MSG_CHECKING([if NR_UNSTABLE_NFS still in use])
- LB2_LINUX_TEST_RESULT([nr_unstable_nfs_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if NR_UNSTABLE_NFS still in use],
+ [nr_unstable_nfs_exists], [
AC_DEFINE(HAVE_NR_UNSTABLE_NFS, 1,
[NR_UNSTABLE_NFS is still in use.])
])
],[])
])
AC_DEFUN([LIBCFS_HAVE_MMAP_LOCK], [
- AC_MSG_CHECKING([if mmap_lock API is available])
- LB2_LINUX_TEST_RESULT([mmap_write_lock], [
+ LB2_MSG_LINUX_TEST_RESULT([if mmap_lock API is available],
+ [mmap_write_lock], [
AC_DEFINE(HAVE_MMAP_LOCK, 1,
[mmap_lock API is available.])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_KERNEL_SETSOCKOPT], [
- AC_MSG_CHECKING([if kernel_setsockopt still in use])
- LB2_LINUX_TEST_RESULT([kernel_setsockopt_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if kernel_setsockopt still in use],
+ [kernel_setsockopt_exists], [
AC_DEFINE(HAVE_KERNEL_SETSOCKOPT, 1,
[kernel_setsockopt still in use])
])
],[-Werror])
])
AC_DEFUN([LIBCFS_KEY_NEED_UNLINK], [
- AC_MSG_CHECKING([if KEY_NEED_UNLINK exists])
- LB2_LINUX_TEST_RESULT([key_need_unlink_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if KEY_NEED_UNLINK exists],
+ [key_need_unlink_exists], [
AC_DEFINE(HAVE_KEY_NEED_UNLINK, 1,
[KEY_NEED_UNLINK exists])
])
],[])
])
AC_DEFUN([LIBCFS_SEC_RELEASE_SECCTX], [
- AC_MSG_CHECKING([if security_release_secctx has 1 arg])
- LB2_LINUX_TEST_RESULT([security_release_secctx_1arg], [
+ LB2_MSG_LINUX_TEST_RESULT([if security_release_secctx has 1 arg],
+ [security_release_secctx_1arg], [
AC_DEFINE(HAVE_SEC_RELEASE_SECCTX_1ARG, 1,
[security_release_secctx has 1 arg.])
])
], [-Werror])
])
AC_DEFUN([LIBCFS_HAVE_KFREE_SENSITIVE], [
- AC_MSG_CHECKING([if kfree_sensitive() is available])
- LB2_LINUX_TEST_RESULT([kfree_sensitive_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if kfree_sensitive() is available],
+ [kfree_sensitive_exists], [
AC_DEFINE(HAVE_KFREE_SENSITIVE, 1,
[kfree_sensitive() is available.])
])
], [-Werror])
])
AC_DEFUN([LIBCFS_HAVE_LIST_CMP_FUNC_T], [
- AC_MSG_CHECKING([if list_cmp_func_t type is defined])
- LB2_LINUX_TEST_RESULT([list_cmp_func_t_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if list_cmp_func_t type is defined],
+ [list_cmp_func_t_exists], [
AC_DEFINE(HAVE_LIST_CMP_FUNC_T, 1,
[list_cmp_func_t type is defined])
])
])
])
AC_DEFUN([LIBCFS_NLA_STRLCPY], [
- AC_MSG_CHECKING([if 'nla_strlcpy()' still exists])
- LB2_LINUX_TEST_RESULT([nla_strlcpy], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'nla_strlcpy()' still exists],
+ [nla_strlcpy], [
AC_DEFINE(HAVE_NLA_STRLCPY, 1,
['nla_strlcpy' is available])
])
],[])
])
AC_DEFUN([LIBCFS_LINUX_FORTIFY_STRING_HEADER],[
- AC_MSG_CHECKING([Is linux/fortify-string.h header available])
- LB2_LINUX_TEST_RESULT([linux_fortify_string_header], [
+ LB2_MSG_LINUX_TEST_RESULT([Is linux/fortify-string.h header available],
+ [linux_fortify_string_header], [
AC_DEFINE(HAVE_LINUX_FORTIFY_STRING_HEADER, 1,
[linux/fortify-string.h header available])
])
], [-Werror])
])
AC_DEFUN([LIBCFS_HAVE_TASK_IS_RUNNING], [
- AC_MSG_CHECKING([if task_is_running() is defined])
- LB2_LINUX_TEST_RESULT([task_is_running], [
+ LB2_MSG_LINUX_TEST_RESULT([if task_is_running() is defined],
+ [task_is_running], [
AC_DEFINE(HAVE_TASK_IS_RUNNING, 1,
[task_is_running() is defined])
])
], [])
])
AC_DEFUN([LIBCFS_PARAM_SET_UINT_MINMAX],[
- AC_MSG_CHECKING([does function 'param_set_uint_minmax' exist])
- LB2_LINUX_TEST_RESULT([param_set_uint_minmax], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'param_set_uint_minmax' exist],
+ [param_set_uint_minmax], [
AC_DEFINE(HAVE_PARAM_SET_UINT_MINMAX, 1,
['param_set_uint_minmax' is available])
])
],[])
])
AC_DEFUN([LIBCFS_PDE_DATA_EXISTS],[
- AC_MSG_CHECKING([does function 'pde_data' exist])
- LB2_LINUX_TEST_RESULT([pde_data], [
+ LB2_MSG_LINUX_TEST_RESULT([does function 'pde_data' exist],
+ [pde_data], [
AC_DEFINE(HAVE_pde_data, 1, [function pde_data() available])
],[
AC_DEFINE(pde_data(inode), PDE_DATA(inode),
],[])
])
AC_DEFUN([LIBCFS_BIO_ALLOC_WITH_BDEV],[
- AC_MSG_CHECKING([does bio_alloc() takes a struct block_device])
- LB2_LINUX_TEST_RESULT([bio_alloc_with_bdev], [
+ LB2_MSG_LINUX_TEST_RESULT([does bio_alloc() takes a struct block_device],
+ [bio_alloc_with_bdev], [
AC_DEFINE(HAVE_BIO_ALLOC_WITH_BDEV, 1,
[bio_alloc() takes a struct block_device])
])
],[])
])
AC_DEFUN([LIBCFS_TIMER_DELETE_SYNC],[
- AC_MSG_CHECKING([is timer_delete_sync() available])
- LB2_LINUX_TEST_RESULT([timer_delete_sync], [
+ LB2_MSG_LINUX_TEST_RESULT([is timer_delete_sync() available],
+ [timer_delete_sync], [
AC_DEFINE(HAVE_TIMER_DELETE_SYNC, 1,
[timer_delete_sync() is available])
],[
],[])
])
AC_DEFUN([LIBCFS_TIMER_DELETE],[
- AC_MSG_CHECKING([is timer_delete() available])
- LB2_LINUX_TEST_RESULT([timer_delete], [
+ LB2_MSG_LINUX_TEST_RESULT([is timer_delete() available],
+ [timer_delete], [
AC_DEFINE(HAVE_TIMER_DELETE, 1,
[timer_delete() is available])
],[
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_RDMA_CREATE_ID_4A], [
- AC_MSG_CHECKING([if 'rdma_create_id' wants four args])
- LB2_LINUX_TEST_RESULT([rdma_create_id_4args], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'rdma_create_id' wants four args],
+ [rdma_create_id_4args], [
AC_DEFINE(HAVE_RDMA_CREATE_ID_4ARG, 1,
[rdma_create_id wants 4 args])
])
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_RDMA_CREATE_ID_5A], [
- AC_MSG_CHECKING([if 'rdma_create_id' wants five args])
- LB2_LINUX_TEST_RESULT([rdma_create_id_5args], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'rdma_create_id' wants five args],
+ [rdma_create_id_5args], [
AC_DEFINE(HAVE_RDMA_CREATE_ID_5ARG, 1,
[rdma_create_id wants 5 args])
])
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_IB_CQ_INIT_ATTR], [
- AC_MSG_CHECKING([if 'struct ib_cq_init_attr' is used])
- LB2_LINUX_TEST_RESULT([ib_cq_init_attr], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct ib_cq_init_attr' is used],
+ [ib_cq_init_attr], [
AC_DEFINE(HAVE_IB_CQ_INIT_ATTR, 1,
[struct ib_cq_init_attr is used by ib_create_cq])
])
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_IB_ALLOC_FAST_REG_MR], [
- AC_MSG_CHECKING([if 'ib_alloc_fast_reg_mr' exists])
- LB2_LINUX_TEST_RESULT([ib_alloc_fast_reg_mr], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'ib_alloc_fast_reg_mr' exists],
+ [ib_alloc_fast_reg_mr], [
AC_DEFINE(HAVE_IB_ALLOC_FAST_REG_MR, 1,
[ib_alloc_fast_reg_mr is defined])
])
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_IB_GET_DMA_MR], [
- AC_MSG_CHECKING([if 'ib_get_dma_mr' exists])
- LB2_LINUX_TEST_RESULT([ib_get_dma_mr], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'ib_get_dma_mr' exists],
+ [ib_get_dma_mr], [
AC_DEFINE(HAVE_IB_GET_DMA_MR, 1,
[ib_get_dma_mr is defined])
])
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_IB_RDMA_WR], [
- AC_MSG_CHECKING([if 'struct ib_rdma_wr' is defined])
- LB2_LINUX_TEST_RESULT([ib_rdma_wr], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct ib_rdma_wr' is defined],
+ [ib_rdma_wr], [
AC_DEFINE(HAVE_IB_RDMA_WR, 1,
[struct ib_rdma_wr is defined])
])
])
# new fast registration API introduced in 4.4
AC_DEFUN([LN_O2IB_IB_MAP_MR_SG_4A], [
- AC_MSG_CHECKING([if 4arg 'ib_map_mr_sg' exists])
- LB2_LINUX_TEST_RESULT([ib_map_mr_sg_4args], [
+ LB2_MSG_LINUX_TEST_RESULT([if 4arg 'ib_map_mr_sg' exists],
+ [ib_map_mr_sg_4args], [
AC_DEFINE(HAVE_IB_MAP_MR_SG, 1,
[ib_map_mr_sg exists])
])
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_IB_MAP_MR_SG_5A], [
- AC_MSG_CHECKING([if 5arg 'ib_map_mr_sg' exists])
- LB2_LINUX_TEST_RESULT([ib_map_mr_sg_5args], [
+ LB2_MSG_LINUX_TEST_RESULT([if 5arg 'ib_map_mr_sg' exists],
+ [ib_map_mr_sg_5args], [
AC_DEFINE(HAVE_IB_MAP_MR_SG, 1,
[ib_map_mr_sg exists])
AC_DEFINE(HAVE_IB_MAP_MR_SG_5ARGS, 1,
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_IB_DEVICE_ATTRS], [
- AC_MSG_CHECKING([if 'struct ib_device' has member 'attrs'])
- LB2_LINUX_TEST_RESULT([ib_device_attrs], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct ib_device' has member 'attrs'],
+ [ib_device_attrs], [
AC_DEFINE(HAVE_IB_DEVICE_ATTRS, 1,
[struct ib_device.attrs is defined])
])
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_IB_ALLOC_PD], [
- AC_MSG_CHECKING([if 2arg 'ib_alloc_pd' exists])
- LB2_LINUX_TEST_RESULT([ib_alloc_pd], [
+ LB2_MSG_LINUX_TEST_RESULT([if 2arg 'ib_alloc_pd' exists],
+ [ib_alloc_pd], [
AC_DEFINE(HAVE_IB_ALLOC_PD_2ARGS, 1,
[ib_alloc_pd has 2 arguments])
])
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_IB_INC_RKEY], [
- AC_MSG_CHECKING([if function 'ib_inc_rkey' is defined])
- LB2_LINUX_TEST_RESULT([ib_inc_rkey], [
+ LB2_MSG_LINUX_TEST_RESULT([if function 'ib_inc_rkey' is defined],
+ [ib_inc_rkey], [
AC_DEFINE(HAVE_IB_INC_RKEY, 1,
[function ib_inc_rkey exist])
])
],[-Werror],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_IB_POST_SEND_CONST], [
- AC_MSG_CHECKING([if 'ib_post_send() and ib_post_recv()' have const parameters])
- LB2_LINUX_TEST_RESULT([ib_post_send_recv_const], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'ib_post_send() and ib_post_recv()' have const parameters],
+ [ib_post_send_recv_const], [
AC_DEFINE(HAVE_IB_POST_SEND_RECV_CONST, 1,
[ib_post_send and ib_post_recv have const parameters])
])
],[-Werror],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_SANE_IB_DMA_MAP_SG], [
- AC_MSG_CHECKING([if ib_dma_map_sg() is sane])
- LB2_LINUX_TEST_RESULT([sane_ib_dma_map_sg], [
+ LB2_MSG_LINUX_TEST_RESULT([if ib_dma_map_sg() is sane],
+ [sane_ib_dma_map_sg], [
AC_DEFINE(HAVE_SANE_IB_DMA_MAP_SG, 1,
[ib_dma_map_sg is sane])
],[],[module])
],[-Werror],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_IB_DEVICE_OPS_EXISTS], [
- AC_MSG_CHECKING([if struct ib_device_ops is defined])
- LB2_LINUX_TEST_RESULT([ib_device_ops_test], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct ib_device_ops is defined],
+ [ib_device_ops_test], [
AC_DEFINE(HAVE_IB_DEVICE_OPS, 1,
[if struct ib_device_ops is defined])
])
],[-Werror],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_IB_SG_DMA_ADDRESS_EXISTS], [
- AC_MSG_CHECKING([if ib_sg_dma_address wrapper exists])
- LB2_LINUX_TEST_RESULT([ib_sg_dma_address_test], [
+ LB2_MSG_LINUX_TEST_RESULT([if ib_sg_dma_address wrapper exists],
+ [ib_sg_dma_address_test], [
AC_DEFINE(HAVE_IB_SG_DMA_ADDRESS, 1,
[if ib_sg_dma_address wrapper exists])
])
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_RDMA_REJECT], [
- AC_MSG_CHECKING([if 4arg 'rdma_reject' exists])
- LB2_LINUX_TEST_RESULT([rdma_reject], [
+ LB2_MSG_LINUX_TEST_RESULT([if 4arg 'rdma_reject' exists],
+ [rdma_reject], [
AC_DEFINE(HAVE_RDMA_REJECT_4ARGS, 1,
[rdma_reject has 4 arguments])
])
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_IB_FMR], [
- AC_MSG_CHECKING([if FMR pools API available])
- LB2_LINUX_TEST_RESULT([ib_fmr], [
+ LB2_MSG_LINUX_TEST_RESULT([if FMR pools API available],
+ [ib_fmr], [
AC_DEFINE(HAVE_FMR_POOL_API, 1,
[FMR pool API is available])
])
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_RDMA_CONNECT_LOCKED], [
- AC_MSG_CHECKING([if 'rdma_connect_locked' exists])
- LB2_LINUX_TEST_RESULT([rdma_connect_locked], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'rdma_connect_locked' exists],
+ [rdma_connect_locked], [
AC_DEFINE(HAVE_RDMA_CONNECT_LOCKED, 1,
[rdma_connect_locked is defined])
])
],[],[$EXTRA_OFED_CONFIG $EXTRA_OFED_INCLUDE])
])
AC_DEFUN([LN_O2IB_ETHTOOL_LINK_SETTINGS], [
- AC_MSG_CHECKING([if 'ethtool_link_settings' exists])
- LB2_LINUX_TEST_RESULT([ethtool_link_settings], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'ethtool_link_settings' exists],
+ [ethtool_link_settings], [
AC_DEFINE(HAVE_ETHTOOL_LINK_SETTINGS, 1,
[ethtool_link_settings is defined])
])
],[-Werror])
])
AC_DEFUN([LN_CONFIG_SOCK_CREATE_KERN], [
- AC_MSG_CHECKING([if 'sock_create_kern' first parameter is net])
- LB2_LINUX_TEST_RESULT([sock_create_kern_net], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'sock_create_kern' first parameter is net],
+ [sock_create_kern_net], [
AC_DEFINE(HAVE_SOCK_CREATE_KERN_USE_NET, 1,
[sock_create_kern use net as first parameter])
])
],[-Werror])
])
AC_DEFUN([LN_CONFIG_SK_DATA_READY], [
- AC_MSG_CHECKING([if 'sk_data_ready' takes only one argument])
- LB2_LINUX_TEST_RESULT([sk_data_ready], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'sk_data_ready' takes only one argument],
+ [sk_data_ready], [
AC_DEFINE(HAVE_SK_DATA_READY_ONE_ARG, 1,
[sk_data_ready uses only one argument])
])
],[-Werror])
])
AC_DEFUN([LN_HAVE_HYPERVISOR_IS_TYPE], [
- AC_MSG_CHECKING([if hypervisor_is_type function is available])
- LB2_LINUX_TEST_RESULT([hypervisor_is_type_exists], [
+ LB2_MSG_LINUX_TEST_RESULT([if hypervisor_is_type function is available],
+ [hypervisor_is_type_exists], [
AC_DEFINE(HAVE_HYPERVISOR_IS_TYPE, 1,
[hypervisor_is_type function exists])
])
])
])
AC_DEFUN([LN_HAVE_ORACLE_OFED_EXTENSIONS], [
- AC_MSG_CHECKING([if Oracle OFED Extensions are enabled])
- LB2_LINUX_TEST_RESULT([oracle_ofed_ext], [
+ LB2_MSG_LINUX_TEST_RESULT([if Oracle OFED Extensions are enabled],
+ [oracle_ofed_ext], [
AC_DEFINE(HAVE_ORACLE_OFED_EXTENSIONS, 1,
[if Oracle OFED Extensions are enabled])
])
],[-Werror])
])
AC_DEFUN([LN_CONFIG_SOCK_GETNAME], [
- AC_MSG_CHECKING([if 'getname' has two args])
- LB2_LINUX_TEST_RESULT([kern_sock_getname_2args], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'getname' has two args],
+ [kern_sock_getname_2args], [
AC_DEFINE(HAVE_KERN_SOCK_GETNAME_2ARGS, 1,
['getname' has two args])
])
],[-Werror])
])
AC_DEFUN([LN_HAVE_IN_DEV_FOR_EACH_IFA_RTNL], [
- AC_MSG_CHECKING([if 'in_dev_for_each_ifa_rtnl' is defined])
- LB2_LINUX_TEST_RESULT([in_dev_for_each_ifa_rtnl_test], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'in_dev_for_each_ifa_rtnl' is defined],
+ [in_dev_for_each_ifa_rtnl_test], [
AC_DEFINE(HAVE_IN_DEV_FOR_EACH_IFA_RTNL, 1,
['in_dev_for_each_ifa_rtnl' is defined])
])
])
])
AC_DEFUN([LC_STACK_SIZE], [
- AC_MSG_CHECKING([if stack size is at least 8k])
- LB2_LINUX_TEST_RESULT([stack_size_8k], [],[
+ LB2_MSG_LINUX_TEST_RESULT([if stack size is at least 8k],
+ [stack_size_8k], [],[
AC_MSG_ERROR(
[Lustre requires that Linux is configured with at least a 8KB stack.])
])
])
])
AC_DEFUN([LC_KEY_TYPE_INSTANTIATE_2ARGS], [
- AC_MSG_CHECKING([if 'key_type->instantiate' has two args])
- LB2_LINUX_TEST_RESULT([key_type_instantiate_2args], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'key_type->instantiate' has two args],
+ [key_type_instantiate_2args], [
AC_DEFINE(HAVE_KEY_TYPE_INSTANTIATE_2ARGS, 1,
[key_type->instantiate has two args])
])
# Check whether to enable Lustre client crypto
#
AC_DEFUN([LC_OPENSSL_SSK], [
-AC_MSG_CHECKING([whether OpenSSL has functions needed for SSK])
AS_IF([test "x$enable_ssk" != xno], [
- AC_MSG_RESULT(
- )
LC_OPENSSL_HMAC
LC_OPENSSL_EVP_PKEY
])
], [
enable_ssk="no"
])
+AC_MSG_CHECKING([whether OpenSSL has functions needed for SSK])
AC_MSG_RESULT([$enable_ssk])
]) # LC_OPENSSL_SSK
])
])
AC_DEFUN([LC_HAVE_DIR_CONTEXT], [
- AC_MSG_CHECKING([if 'dir_context' exist])
- LB2_LINUX_TEST_RESULT([dir_context], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'dir_context' exist],
+ [dir_context], [
AC_DEFINE(HAVE_DIR_CONTEXT, 1, [dir_context exist])
])
]) # LC_HAVE_DIR_CONTEXT
])
])
AC_DEFUN([LC_D_COMPARE_5ARGS], [
- AC_MSG_CHECKING([if 'd_compare' taken 5 arguments])
- LB2_LINUX_TEST_RESULT([d_compare_5args], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'd_compare' taken 5 arguments],
+ [d_compare_5args], [
AC_DEFINE(HAVE_D_COMPARE_5ARGS, 1,
[d_compare need 5 arguments])
])
])
])
AC_DEFUN([LC_HAVE_DCOUNT], [
- AC_MSG_CHECKING([if 'd_count' exists])
- LB2_LINUX_TEST_RESULT([d_count], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'd_count' exists],
+ [d_count], [
AC_DEFINE(HAVE_D_COUNT, 1, [d_count exist])
])
]) # LC_HAVE_DCOUNT
])
])
AC_DEFUN([LC_PID_NS_FOR_CHILDREN], [
- AC_MSG_CHECKING([if 'struct nsproxy' has 'pid_ns_for_children'])
- LB2_LINUX_TEST_RESULT([pid_ns_for_children], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct nsproxy' has 'pid_ns_for_children'],
+ [pid_ns_for_children], [
AC_DEFINE(HAVE_PID_NS_FOR_CHILDREN, 1,
['struct nsproxy' has 'pid_ns_for_children'])
])
])
])
AC_DEFUN([LC_OLDSIZE_TRUNCATE_PAGECACHE], [
- AC_MSG_CHECKING([if 'truncate_pagecache' with 'old_size' parameter])
- LB2_LINUX_TEST_RESULT([truncate_pagecache_old_size], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'truncate_pagecache' with 'old_size' parameter],
+ [truncate_pagecache_old_size], [
AC_DEFINE(HAVE_OLDSIZE_TRUNCATE_PAGECACHE, 1,
[with oldsize])
])
])
])
AC_DEFUN([LC_PTR_ERR_OR_ZERO_MISSING], [
- AC_MSG_CHECKING([if 'PTR_ERR_OR_ZERO' is missing])
- LB2_LINUX_TEST_RESULT([is_err_or_null], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'PTR_ERR_OR_ZERO' is missing],
+ [is_err_or_null], [
AC_DEFINE(HAVE_PTR_ERR_OR_ZERO, 1,
['PTR_ERR_OR_ZERO' exist])
])
])
])
AC_DEFUN([LC_HAVE_DENTRY_D_U_D_ALIAS_LIST], [
- AC_MSG_CHECKING([if list 'dentry.d_u.d_alias' exist])
- LB2_LINUX_TEST_RESULT([d_alias_list], [
+ LB2_MSG_LINUX_TEST_RESULT([if list 'dentry.d_u.d_alias' exist],
+ [d_alias_list], [
AC_DEFINE(HAVE_DENTRY_D_U_D_ALIAS, 1,
[list dentry.d_u.d_alias exist])
])
])
])
AC_DEFUN([LC_HAVE_DENTRY_D_U_D_ALIAS_HLIST], [
- AC_MSG_CHECKING([if hlist 'dentry.d_u.d_alias' exist])
- LB2_LINUX_TEST_RESULT([d_alias_hlist], [
+ LB2_MSG_LINUX_TEST_RESULT([if hlist 'dentry.d_u.d_alias' exist],
+ [d_alias_hlist], [
AC_DEFINE(HAVE_DENTRY_D_U_D_ALIAS, 1,
[list dentry.d_u.d_alias exist])
])
])
])
AC_DEFUN([LC_HAVE_DENTRY_D_CHILD], [
- AC_MSG_CHECKING([if 'dentry.d_child' exist])
- LB2_LINUX_TEST_RESULT([d_child], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'dentry.d_child' exist],
+ [d_child], [
AC_DEFINE(HAVE_DENTRY_D_CHILD, 1, [dentry.d_child exist])
])
]) # LC_HAVE_DENTRY_D_CHILD
])
])
AC_DEFUN([LC_KIOCB_KI_LEFT], [
- AC_MSG_CHECKING([if 'struct kiocb' with 'ki_left' member])
- LB2_LINUX_TEST_RESULT([kiocb_ki_left], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct kiocb' with 'ki_left' member],
+ [kiocb_ki_left], [
AC_DEFINE(HAVE_KIOCB_KI_LEFT, 1,
[ki_left exist])
])
],[])
])
AC_DEFUN([LC_REGISTER_SHRINKER_RET], [
- AC_MSG_CHECKING([if register_shrinker() returns status])
- LB2_LINUX_TEST_RESULT([register_shrinker_ret], [
+ LB2_MSG_LINUX_TEST_RESULT([if register_shrinker() returns status],
+ [register_shrinker_ret], [
AC_DEFINE(HAVE_REGISTER_SHRINKER_RET, 1,
[register_shrinker() returns status])
])
])
])
AC_DEFUN([LC_VFS_RENAME_5ARGS], [
- AC_MSG_CHECKING([if Linux kernel has 'vfs_rename' with 5 args])
- LB2_LINUX_TEST_RESULT([vfs_rename_5args], [
+ LB2_MSG_LINUX_TEST_RESULT([if Linux kernel has 'vfs_rename' with 5 args],
+ [vfs_rename_5args], [
AC_DEFINE(HAVE_VFS_RENAME_5ARGS, 1,
[kernel has vfs_rename with 5 args])
])
])
])
AC_DEFUN([LC_VFS_UNLINK_3ARGS], [
- AC_MSG_CHECKING([if Linux kernel has 'vfs_unlink' with 3 args])
- LB2_LINUX_TEST_RESULT([vfs_unlink_3args], [
+ LB2_MSG_LINUX_TEST_RESULT([if Linux kernel has 'vfs_unlink' with 3 args],
+ [vfs_unlink_3args], [
AC_DEFINE(HAVE_VFS_UNLINK_3ARGS, 1,
[kernel has vfs_unlink with 3 args])
])
])
])
AC_DEFUN([LC_HAVE_D_IS_POSITIVE], [
- AC_MSG_CHECKING([if 'd_is_positive' exist])
- LB2_LINUX_TEST_RESULT([d_is_positive], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'd_is_positive' exist],
+ [d_is_positive], [
AC_DEFINE(HAVE_D_IS_POSITIVE, 1,
['d_is_positive' is available])
])
])
])
AC_DEFUN([LC_HAVE_BVEC_ITER], [
- AC_MSG_CHECKING([if Linux kernel has struct bvec_iter])
- LB2_LINUX_TEST_RESULT([have_bvec_iter], [
+ LB2_MSG_LINUX_TEST_RESULT([if Linux kernel has struct bvec_iter],
+ [have_bvec_iter], [
AC_DEFINE(HAVE_BVEC_ITER, 1,
[kernel has struct bvec_iter])
])
])
])
AC_DEFUN([LC_IOP_SET_ACL], [
- AC_MSG_CHECKING([if 'inode_operations' has '.set_acl' member function])
- LB2_LINUX_TEST_RESULT([inode_ops_set_acl], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'inode_operations' has '.set_acl' member function],
+ [inode_ops_set_acl], [
AC_DEFINE(HAVE_IOP_SET_ACL, 1,
[inode_operations has .set_acl member function])
])
])
])
AC_DEFUN([LC_HAVE_TRUNCATE_IPAGES_FINAL], [
- AC_MSG_CHECKING([if Linux kernel has truncate_inode_pages_final])
- LB2_LINUX_TEST_RESULT([truncate_ipages_final], [
+ LB2_MSG_LINUX_TEST_RESULT([if Linux kernel has truncate_inode_pages_final],
+ [truncate_ipages_final], [
AC_DEFINE(HAVE_TRUNCATE_INODE_PAGES_FINAL, 1,
[kernel has truncate_inode_pages_final])
])
])
]) # LC_IOPS_RENAME_WITH_FLAGS
AC_DEFUN([LC_IOPS_RENAME_WITH_FLAGS], [
- AC_MSG_CHECKING([if 'inode_operations->rename' taken flags as argument])
- LB2_LINUX_TEST_RESULT([iops_rename_with_flags], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'inode_operations->rename' taken flags as argument],
+ [iops_rename_with_flags], [
AC_DEFINE(HAVE_IOPS_RENAME_WITH_FLAGS, 1,
[inode_operations->rename need flags as argument])
])
])
])
AC_DEFUN([LC_VFS_RENAME_6ARGS], [
- AC_MSG_CHECKING([if Linux kernel has 'vfs_rename' with 6 args])
- LB2_LINUX_TEST_RESULT([vfs_rename_6args], [
+ LB2_MSG_LINUX_TEST_RESULT([if Linux kernel has 'vfs_rename' with 6 args],
+ [vfs_rename_6args], [
AC_DEFINE(HAVE_VFS_RENAME_6ARGS, 1,
[kernel has vfs_rename with 6 args])
])
])
])
AC_DEFUN([LC_DIRECTIO_USE_ITER], [
- AC_MSG_CHECKING([if direct IO uses iov_iter])
- LB2_LINUX_TEST_RESULT([direct_io_iter], [
+ LB2_MSG_LINUX_TEST_RESULT([if direct IO uses iov_iter],
+ [direct_io_iter], [
AC_DEFINE(HAVE_DIRECTIO_ITER, 1, [direct IO uses iov_iter])
])
]) # LC_DIRECTIO_USE_ITER
],[-Werror])
])
AC_DEFUN([LC_HAVE_IOV_ITER_INIT_DIRECTION], [
- AC_MSG_CHECKING([if 'iov_iter_init' takes a tag])
- LB2_LINUX_TEST_RESULT([iter_init], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'iov_iter_init' takes a tag],
+ [iter_init], [
AC_DEFINE(HAVE_IOV_ITER_INIT_DIRECTION, 1,
[iov_iter_init handles directional tag])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_IOV_ITER_TRUNCATE], [
- AC_MSG_CHECKING([if 'iov_iter_truncate' exists])
- LB2_LINUX_TEST_RESULT([iter_truncate], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'iov_iter_truncate' exists],
+ [iter_truncate], [
AC_DEFINE(HAVE_IOV_ITER_TRUNCATE, 1, [iov_iter_truncate exists])
])
]) # LC_HAVE_IOV_ITER_TRUNCATE
])
])
AC_DEFUN([LC_HAVE_FILE_OPERATIONS_READ_WRITE_ITER], [
- AC_MSG_CHECKING([if 'file_operations.[read|write]_iter' exist])
- LB2_LINUX_TEST_RESULT([file_function_iter], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'file_operations.[read|write]_iter' exist],
+ [file_function_iter], [
AC_DEFINE(HAVE_FILE_OPERATIONS_READ_WRITE_ITER, 1,
[file_operations.[read|write]_iter functions exist])
])
])
])
AC_DEFUN([LC_PAGECACHE_GET_PAGE], [
- AC_MSG_CHECKING([if 'pagecache_get_page' exists])
- LB2_LINUX_TEST_RESULT([pagecache_get_page], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'pagecache_get_page' exists],
+ [pagecache_get_page], [
AC_DEFINE(HAVE_PAGECACHE_GET_PAGE, 1,
['pagecache_get_page' is available])
])
])
])
AC_DEFUN([LC_HAVE_INTERVAL_BLK_INTEGRITY], [
- AC_MSG_CHECKING([if 'blk_integrity.interval' exist])
- LB2_LINUX_TEST_RESULT([interval_blk_integrity], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'blk_integrity.interval' exist],
+ [interval_blk_integrity], [
AC_DEFINE(HAVE_INTERVAL_BLK_INTEGRITY, 1,
[blk_integrity.interval exist])
])
])
])
AC_DEFUN([LC_KEY_MATCH_DATA], [
- AC_MSG_CHECKING([if struct key_match field exist])
- LB2_LINUX_TEST_RESULT([key_match], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct key_match field exist],
+ [key_match], [
AC_DEFINE(HAVE_KEY_MATCH_DATA, 1, [struct key_match_data exist])
])
]) # LC_KEY_MATCH_DATA
])
])
AC_DEFUN([LC_HAVE_BLK_INTEGRITY_ITER], [
- AC_MSG_CHECKING([if struct blk_integrity_iter exist])
- LB2_LINUX_TEST_RESULT([blk_integrity_iter], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct blk_integrity_iter exist],
+ [blk_integrity_iter], [
AC_DEFINE(HAVE_BLK_INTEGRITY_ITER, 1,
[kernel has struct blk_integrity_iter])
])
],[-Werror])
])
AC_DEFUN([LC_NFS_FILLDIR_USE_CTX], [
- AC_MSG_CHECKING([if filldir_t uses struct dir_context])
- LB2_LINUX_TEST_RESULT([filldir_ctx], [
+ LB2_MSG_LINUX_TEST_RESULT([if filldir_t uses struct dir_context],
+ [filldir_ctx], [
AC_DEFINE(HAVE_FILLDIR_USE_CTX, 1,
[filldir_t needs struct dir_context as argument])
])
])
])
AC_DEFUN([LC_PERCPU_COUNTER_INIT], [
- AC_MSG_CHECKING([if percpu_counter_init uses GFP_* flag as argument])
- LB2_LINUX_TEST_RESULT([percpu_counter_init], [
+ LB2_MSG_LINUX_TEST_RESULT([if percpu_counter_init uses GFP_* flag as argument],
+ [percpu_counter_init], [
AC_DEFINE(HAVE_PERCPU_COUNTER_INIT_GFP_FLAG, 1,
[percpu_counter_init uses GFP_* flag])
])
])
])
AC_DEFUN([LC_KIOCB_HAS_NBYTES], [
- AC_MSG_CHECKING([if struct kiocb has ki_nbytes field])
- LB2_LINUX_TEST_RESULT([ki_nbytes], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct kiocb has ki_nbytes field],
+ [ki_nbytes], [
AC_DEFINE(HAVE_KI_NBYTES, 1, [ki_nbytes field exist])
])
]) # LC_KIOCB_HAS_NBYTES
],[-Werror])
])
AC_DEFUN([LC_HAVE_DQUOT_QC_DQBLK], [
- AC_MSG_CHECKING([if 'quotactl_ops.set_dqblk' takes struct qc_dqblk])
- LB2_LINUX_TEST_RESULT([qc_dqblk], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'quotactl_ops.set_dqblk' takes struct qc_dqblk],
+ [qc_dqblk], [
AC_DEFINE(HAVE_DQUOT_QC_DQBLK, 1,
[quotactl_ops.set_dqblk takes struct qc_dqblk])
AC_DEFINE(HAVE_DQUOT_KQID, 1,
])
])
AC_DEFUN([LC_HAVE_AIO_COMPLETE], [
- AC_MSG_CHECKING([if kernel has exported aio_complete()])
- LB2_LINUX_TEST_RESULT([aio_complete], [
+ LB2_MSG_LINUX_TEST_RESULT([if kernel has exported aio_complete()],
+ [aio_complete], [
AC_DEFINE(HAVE_AIO_COMPLETE, 1, [aio_complete defined])
])
]) # LC_HAVE_AIO_COMPLETE
],[])
])
AC_DEFUN([LC_HAVE_IS_ROOT_INODE], [
- AC_MSG_CHECKING([if kernel has is_root_inode()])
- LB2_LINUX_TEST_RESULT([is_root_inode], [
+ LB2_MSG_LINUX_TEST_RESULT([if kernel has is_root_inode()],
+ [is_root_inode], [
AC_DEFINE(HAVE_IS_ROOT_INODE, 1, [is_root_inode defined])
])
]) # LC_HAVE_IS_ROOT_INODE
])
])
AC_DEFUN([LC_BACKING_DEV_INFO_REMOVAL], [
- AC_MSG_CHECKING([if struct address_space has backing_dev_info])
- LB2_LINUX_TEST_RESULT([backing_dev_info], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct address_space has backing_dev_info],
+ [backing_dev_info], [
AC_DEFINE(HAVE_BACKING_DEV_INFO, 1, [backing_dev_info exist])
])
]) # LC_BACKING_DEV_INFO_REMOVAL
])
])
AC_DEFUN([LC_HAVE_PROJECT_QUOTA], [
- AC_MSG_CHECKING([if get_projid exists])
- LB2_LINUX_TEST_RESULT([get_projid], [
+ LB2_MSG_LINUX_TEST_RESULT([if get_projid exists],
+ [get_projid], [
AC_DEFINE(HAVE_PROJECT_QUOTA, 1,
[get_projid function exists])
])
])
])
AC_DEFUN([LC_IOV_ITER_RW], [
- AC_MSG_CHECKING([if iov_iter_rw exist])
- LB2_LINUX_TEST_RESULT([iov_iter_rw], [
+ LB2_MSG_LINUX_TEST_RESULT([if iov_iter_rw exist],
+ [iov_iter_rw], [
AC_DEFINE(HAVE_IOV_ITER_RW, 1, [iov_iter_rw exist])
])
]) # LC_IOV_ITER_RW
])
])
AC_DEFUN([LC_HAVE___BI_CNT], [
- AC_MSG_CHECKING([if Linux kernel has __bi_cnt in struct bio])
- LB2_LINUX_TEST_RESULT([have___bi_cnt], [
+ LB2_MSG_LINUX_TEST_RESULT([if Linux kernel has __bi_cnt in struct bio],
+ [have___bi_cnt], [
AC_DEFINE(HAVE___BI_CNT, 1, [struct bio has __bi_cnt])
])
]) # LC_HAVE___BI_CNT
])
])
AC_DEFUN([LC_SYMLINK_OPS_USE_NAMEIDATA], [
- AC_MSG_CHECKING([if symlink inode operations have struct nameidata argument])
- LB2_LINUX_TEST_RESULT([symlink_use_nameidata], [
+ LB2_MSG_LINUX_TEST_RESULT([if symlink inode operations have struct nameidata argument],
+ [symlink_use_nameidata], [
AC_DEFINE(HAVE_SYMLINK_OPS_USE_NAMEIDATA, 1,
[symlink inode operations need struct nameidata argument])
])
])
])
AC_DEFUN([LC_BIO_ENDIO_USES_ONE_ARG], [
- AC_MSG_CHECKING([if 'bio_endio' with one argument exist])
- LB2_LINUX_TEST_RESULT([bio_endio], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'bio_endio' with one argument exist],
+ [bio_endio], [
AC_DEFINE(HAVE_BIO_ENDIO_USES_ONE_ARG, 1,
[bio_endio takes only one argument])
])
])
])
AC_DEFUN([LC_ACCOUNT_PAGE_DIRTIED_3ARGS], [
- AC_MSG_CHECKING([if 'account_page_dirtied' with 3 args exists])
- LB2_LINUX_TEST_RESULT([account_page_dirtied_3a], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'account_page_dirtied' with 3 args exists],
+ [account_page_dirtied_3a], [
AC_DEFINE(HAVE_ACCOUNT_PAGE_DIRTIED_3ARGS, 1,
[account_page_dirtied takes three arguments])
])
])
])
AC_DEFUN([LC_HAVE_CRYPTO_ALLOC_SKCIPHER], [
- AC_MSG_CHECKING([if crypto_alloc_skcipher is defined])
- LB2_LINUX_TEST_RESULT([crypto_alloc_skcipher], [
+ LB2_MSG_LINUX_TEST_RESULT([if crypto_alloc_skcipher is defined],
+ [crypto_alloc_skcipher], [
AC_DEFINE(HAVE_CRYPTO_ALLOC_SKCIPHER, 1,
[crypto_alloc_skcipher is defined])
])
])
])
AC_DEFUN([LC_HAVE_INTERVAL_EXP_BLK_INTEGRITY], [
- AC_MSG_CHECKING([if 'blk_integrity.interval_exp' exist])
- LB2_LINUX_TEST_RESULT([blk_integrity_interval_exp], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'blk_integrity.interval_exp' exist],
+ [blk_integrity_interval_exp], [
AC_DEFINE(HAVE_INTERVAL_EXP_BLK_INTEGRITY, 1,
[blk_integrity.interval_exp exist])
])
])
])
AC_DEFUN([LC_HAVE_CACHE_HEAD_HLIST], [
- AC_MSG_CHECKING([if 'struct cache_head' has 'cache_list' field])
- LB2_LINUX_TEST_RESULT([cache_head_has_hlist], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct cache_head' has 'cache_list' field],
+ [cache_head_has_hlist], [
AC_DEFINE(HAVE_CACHE_HEAD_HLIST, 1,
[cache_head has hlist cache_list])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_XATTR_HANDLER_SIMPLIFIED], [
- AC_MSG_CHECKING([if 'struct xattr_handler' functions pass in handler pointer])
- LB2_LINUX_TEST_RESULT([xattr_handler_simplified], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct xattr_handler' functions pass in handler pointer],
+ [xattr_handler_simplified], [
AC_DEFINE(HAVE_XATTR_HANDLER_SIMPLIFIED, 1,
[handler pointer is parameter])
])
])
])
AC_DEFUN([LC_HAVE_BIP_ITER_BIO_INTEGRITY_PAYLOAD], [
- AC_MSG_CHECKING([if 'bio_integrity_payload.bip_iter' exist])
- LB2_LINUX_TEST_RESULT([bio_integrity_payload_bip_iter], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'bio_integrity_payload.bip_iter' exist],
+ [bio_integrity_payload_bip_iter], [
AC_DEFINE(HAVE_BIP_ITER_BIO_INTEGRITY_PAYLOAD, 1,
[bio_integrity_payload.bip_iter exist])
])
])
])
AC_DEFUN([LC_BIO_INTEGRITY_PREP_FN], [
- AC_MSG_CHECKING([if 'bio_integrity_prep_fn' exists])
- LB2_LINUX_TEST_RESULT([bio_integrity_prep_fn], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'bio_integrity_prep_fn' exists],
+ [bio_integrity_prep_fn], [
AC_DEFINE(HAVE_BIO_INTEGRITY_PREP_FN, 1,
[kernel has bio_integrity_prep_fn])
AC_SUBST(PATCHED_INTEGRITY_INTF)
])
])
AC_DEFUN([LC_BIO_INTEGRITY_PREP_FN_RETURNS_BOOL], [
- AC_MSG_CHECKING([if 'bio_integrity_prep_fn' returns bool])
- LB2_LINUX_TEST_RESULT([bio_integrity_prep_ret_bool], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'bio_integrity_prep_fn' returns bool],
+ [bio_integrity_prep_ret_bool], [
AC_DEFINE(HAVE_BIO_INTEGRITY_PREP_FN_RETURNS_BOOL, 1,
[bio_integrity_prep_fn returns bool])
])
])
])
AC_DEFUN([LC_HAVE_BI_OPF], [
- AC_MSG_CHECKING([if Linux kernel has bi_opf in struct bio])
- LB2_LINUX_TEST_RESULT([have_bi_opf], [
+ LB2_MSG_LINUX_TEST_RESULT([if Linux kernel has bi_opf in struct bio],
+ [have_bi_opf], [
AC_DEFINE(HAVE_BI_OPF, 1, [struct bio has bi_opf])
])
]) # LC_HAVE_BI_OPF
])
])
AC_DEFUN([LC_HAVE_SUBMIT_BIO_2ARGS], [
- AC_MSG_CHECKING([if submit_bio takes two arguments])
- LB2_LINUX_TEST_RESULT([have_submit_bio_2args], [
+ LB2_MSG_LINUX_TEST_RESULT([if submit_bio takes two arguments],
+ [have_submit_bio_2args], [
AC_DEFINE(HAVE_SUBMIT_BIO_2ARGS, 1,
[submit_bio takes two arguments])
])
])
])
AC_DEFUN([LC_HAVE_CLEAN_BDEV_ALIASES], [
- AC_MSG_CHECKING([if kernel has clean_bdev_aliases])
- LB2_LINUX_TEST_RESULT([have_clean_bdev_aliases], [
+ LB2_MSG_LINUX_TEST_RESULT([if kernel has clean_bdev_aliases],
+ [have_clean_bdev_aliases], [
AC_DEFINE(HAVE_CLEAN_BDEV_ALIASES, 1,
[kernel has clean_bdev_aliases])
])
])
])
AC_DEFUN([LC_HAVE_LOCKS_LOCK_FILE_WAIT], [
- AC_MSG_CHECKING([if 'locks_lock_file_wait' exists])
- LB2_LINUX_TEST_RESULT([locks_lock_file_wait], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'locks_lock_file_wait' exists],
+ [locks_lock_file_wait], [
AC_DEFINE(HAVE_LOCKS_LOCK_FILE_WAIT, 1,
[kernel has locks_lock_file_wait])
])
])
])
AC_DEFUN([LC_HAVE_KEY_PAYLOAD_DATA_ARRAY], [
- AC_MSG_CHECKING([if 'struct key' has 'payload.data' as an array])
- LB2_LINUX_TEST_RESULT([key_payload_data_array], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct key' has 'payload.data' as an array],
+ [key_payload_data_array], [
AC_DEFINE(HAVE_KEY_PAYLOAD_DATA_ARRAY, 1, [payload.data is an array])
])
]) # LC_HAVE_KEY_PAYLOAD_DATA_ARRAY
],[-Werror])
])
AC_DEFUN([LC_HAVE_XATTR_HANDLER_NAME], [
- AC_MSG_CHECKING([if 'struct xattr_handler' has a name member])
- LB2_LINUX_TEST_RESULT([xattr_handler_name], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct xattr_handler' has a name member],
+ [xattr_handler_name], [
AC_DEFINE(HAVE_XATTR_HANDLER_NAME, 1,
[xattr_handler has a name member])
])
])
])
AC_DEFUN([LC_HAVE_FILE_DENTRY], [
- AC_MSG_CHECKING([if Linux kernel has 'file_dentry'])
- LB2_LINUX_TEST_RESULT([file_dentry], [
+ LB2_MSG_LINUX_TEST_RESULT([if Linux kernel has 'file_dentry'],
+ [file_dentry], [
AC_DEFINE(HAVE_FILE_DENTRY, 1, [kernel has file_dentry])
])
]) # LC_HAVE_FILE_DENTRY
])
])
AC_DEFUN([LC_HAVE_INODE_LOCK], [
- AC_MSG_CHECKING([if 'inode_lock' is defined])
- LB2_LINUX_TEST_RESULT([inode_lock], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'inode_lock' is defined],
+ [inode_lock], [
AC_DEFINE(HAVE_INODE_LOCK, 1, [inode_lock is defined])
])
]) # LC_HAVE_INODE_LOCK
])
])
AC_DEFUN([LC_HAVE_IOP_GET_LINK], [
- AC_MSG_CHECKING([if 'iop' has 'get_link'])
- LB2_LINUX_TEST_RESULT([inode_ops_get_link], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'iop' has 'get_link'],
+ [inode_ops_get_link], [
AC_DEFINE(HAVE_IOP_GET_LINK, 1, [have iop get_link])
])
]) # LC_HAVE_IOP_GET_LINK
])
])
AC_DEFUN([LC_HAVE_IN_COMPAT_SYSCALL], [
- AC_MSG_CHECKING([if 'in_compat_syscall' is defined])
- LB2_LINUX_TEST_RESULT([in_compat_syscall], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'in_compat_syscall' is defined],
+ [in_compat_syscall], [
AC_DEFINE(HAVE_IN_COMPAT_SYSCALL, 1, [have in_compat_syscall])
])
]) # LC_HAVE_IN_COMPAT_SYSCALL
],[-Werror])
])
AC_DEFUN([LC_HAVE_XATTR_HANDLER_INODE_PARAM], [
- AC_MSG_CHECKING([if 'struct xattr_handler' functions have inode parameter])
- LB2_LINUX_TEST_RESULT([xattr_handler_inode_param], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct xattr_handler' functions have inode parameter],
+ [xattr_handler_inode_param], [
AC_DEFINE(HAVE_XATTR_HANDLER_INODE_PARAM, 1, [needs inode parameter])
])
]) # LC_HAVE_XATTR_HANDLER_INODE_PARAM
],[-Werror])
])
AC_DEFUN([LC_D_IN_LOOKUP], [
- AC_MSG_CHECKING([if 'd_in_lookup' is defined])
- LB2_LINUX_TEST_RESULT([d_in_lookup], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'd_in_lookup' is defined],
+ [d_in_lookup], [
AC_DEFINE(HAVE_D_IN_LOOKUP, 1, [d_in_lookup is defined])
])
]) # LC_D_IN_LOOKUP
],[-Werror])
])
AC_DEFUN([LC_LOCK_PAGE_MEMCG], [
- AC_MSG_CHECKING([if 'lock_page_memcg' is defined])
- LB2_LINUX_TEST_RESULT([lock_page_memcg], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'lock_page_memcg' is defined],
+ [lock_page_memcg], [
AC_DEFINE(HAVE_LOCK_PAGE_MEMCG, 1, [lock_page_memcg is defined])
])
]) # LC_LOCK_PAGE_MEMCG
])
])
AC_DEFUN([LC_HAVE_DOWN_WRITE_KILLABLE], [
- AC_MSG_CHECKING([if down_write_killable exists])
- LB2_LINUX_TEST_RESULT([down_write_killable], [
+ LB2_MSG_LINUX_TEST_RESULT([if down_write_killable exists],
+ [down_write_killable], [
AC_DEFINE(HAVE_DOWN_WRITE_KILLABLE, 1,
[down_write_killable function exists])
])
])
])
AC_DEFUN([LC_D_INIT], [
- AC_MSG_CHECKING([if dentry operations supports 'd_init'])
- LB2_LINUX_TEST_RESULT([d_init], [
+ LB2_MSG_LINUX_TEST_RESULT([if dentry operations supports 'd_init'],
+ [d_init], [
AC_DEFINE(HAVE_D_INIT, 1, ['d_init' exists])
])
]) # LC_D_INIT
])
])
AC_DEFUN([LC_DIRECTIO_2ARGS], [
- AC_MSG_CHECKING([if '->direct_IO()' takes 2 arguments])
- LB2_LINUX_TEST_RESULT([direct_io_2args], [
+ LB2_MSG_LINUX_TEST_RESULT([if '->direct_IO()' takes 2 arguments],
+ [direct_io_2args], [
AC_DEFINE(HAVE_DIRECTIO_2ARGS, 1, [direct_IO has 2 arguments])
])
]) # LC_DIRECTIO_2ARGS
])
])
AC_DEFUN([LC_GENERIC_WRITE_SYNC_2ARGS], [
- AC_MSG_CHECKING([if 'generic_write_sync()' takes 2 arguments])
- LB2_LINUX_TEST_RESULT([generic_write_sync_2args], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'generic_write_sync()' takes 2 arguments],
+ [generic_write_sync_2args], [
AC_DEFINE(HAVE_GENERIC_WRITE_SYNC_2ARGS, 1,
[generic_write_sync has 2 arguments])
])
])
])
AC_DEFUN([LC_FOP_ITERATE_SHARED], [
- AC_MSG_CHECKING([if 'file_operations' has 'iterate_shared'])
- LB2_LINUX_TEST_RESULT([fop_iterate_shared], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'file_operations' has 'iterate_shared'],
+ [fop_iterate_shared], [
AC_DEFINE(HAVE_FOP_ITERATE_SHARED, 1,
[file_operations has iterate_shared])
])
])
])
AC_DEFUN([LC_HAVE_POSIX_ACL_VALID_USER_NS], [
- AC_MSG_CHECKING([if 'posix_acl_valid' takes 'struct user_namespace'])
- LB2_LINUX_TEST_RESULT([posix_acl_valid], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'posix_acl_valid' takes 'struct user_namespace'],
+ [posix_acl_valid], [
AC_DEFINE(HAVE_POSIX_ACL_VALID_USER_NS, 1,
[posix_acl_valid takes struct user_namespace])
])
])
])
AC_DEFUN([LC_D_COMPARE_4ARGS], [
- AC_MSG_CHECKING([if 'd_compare' taken 4 arguments])
- LB2_LINUX_TEST_RESULT([d_compare_4args], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'd_compare' taken 4 arguments],
+ [d_compare_4args], [
AC_DEFINE(HAVE_D_COMPARE_4ARGS, 1,
[d_compare need 4 arguments])
])
])
])
AC_DEFUN([LC_FULL_NAME_HASH_3ARGS], [
- AC_MSG_CHECKING([if 'full_name_hash' taken 3 arguments])
- LB2_LINUX_TEST_RESULT([full_name_hash_3args], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'full_name_hash' taken 3 arguments],
+ [full_name_hash_3args], [
AC_DEFINE(HAVE_FULL_NAME_HASH_3ARGS, 1,
[full_name_hash need 3 arguments])
])
])
])
AC_DEFUN([LC_STRUCT_POSIX_ACL_XATTR], [
- AC_MSG_CHECKING([if 'struct posix_acl_xattr_{header,entry}' defined])
- LB2_LINUX_TEST_RESULT([struct_posix_acl_xattr], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct posix_acl_xattr_{header,entry}' defined],
+ [struct_posix_acl_xattr], [
AC_DEFINE(HAVE_STRUCT_POSIX_ACL_XATTR, 1,
[struct posix_acl_xattr_{header,entry} defined])
])
])
])
AC_DEFUN([LC_IOP_XATTR], [
- AC_MSG_CHECKING([if 'inode_operations' has {get,set,remove}xattr members])
- LB2_LINUX_TEST_RESULT([inode_ops_xattr], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'inode_operations' has {get,set,remove}xattr members],
+ [inode_ops_xattr], [
AC_DEFINE(HAVE_IOP_XATTR, 1,
[inode_operations has {get,set,remove}xattr members])
])
])
])
AC_DEFUN([LC_GROUP_INFO_GID], [
- AC_MSG_CHECKING([if 'struct group_info' has member 'gid'])
- LB2_LINUX_TEST_RESULT([group_info_gid], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct group_info' has member 'gid'],
+ [group_info_gid], [
AC_DEFINE(HAVE_GROUP_INFO_GID, 1,
[struct group_info has member gid])
])
])
])
AC_DEFUN([LC_VFS_SETXATTR], [
- AC_MSG_CHECKING([if '__vfs_setxattr' helper is available])
- LB2_LINUX_TEST_RESULT([vfs_setxattr], [
+ LB2_MSG_LINUX_TEST_RESULT([if '__vfs_setxattr' helper is available],
+ [vfs_setxattr], [
AC_DEFINE(HAVE_VFS_SETXATTR, 1, ['__vfs_setxattr' is available])
])
]) # LC_VFS_SETXATTR
])
])
AC_DEFUN([LC_POSIX_ACL_UPDATE_MODE], [
- AC_MSG_CHECKING([if 'posix_acl_update_mode' exists])
- LB2_LINUX_TEST_RESULT([posix_acl_update_mode], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'posix_acl_update_mode' exists],
+ [posix_acl_update_mode], [
AC_DEFINE(HAVE_POSIX_ACL_UPDATE_MODE, 1,
['posix_acl_update_mode' is available])
])
])
])
AC_DEFUN([LC_HAVE_BDI_IO_PAGES], [
- AC_MSG_CHECKING([if 'struct backing_dev_info' has 'io_pages' field])
- LB2_LINUX_TEST_RESULT([bdi_has_io_pages], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct backing_dev_info' has 'io_pages' field],
+ [bdi_has_io_pages], [
AC_DEFINE(HAVE_BDI_IO_PAGES, 1,
[backing_dev_info has io_pages])
])
])
])
AC_DEFUN([LC_IOP_GENERIC_READLINK], [
- AC_MSG_CHECKING([if 'generic_readlink' still exist])
- LB2_LINUX_TEST_RESULT([inode_ops_readlink], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'generic_readlink' still exist],
+ [inode_ops_readlink], [
AC_DEFINE(HAVE_IOP_GENERIC_READLINK, 1,
[generic_readlink has been removed])
])
])
])
AC_DEFUN([LC_HAVE_VM_FAULT_ADDRESS], [
- AC_MSG_CHECKING([if 'struct vm_fault' replaced virtual_address with address field])
- LB2_LINUX_TEST_RESULT([vm_fault_address], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct vm_fault' replaced virtual_address with address field],
+ [vm_fault_address], [
AC_DEFINE(HAVE_VM_FAULT_ADDRESS, 1,
[virtual_address has been replaced by address field])
])
])
])
AC_DEFUN([LC_INODEOPS_ENHANCED_GETATTR], [
- AC_MSG_CHECKING([if 'inode_operations' getattr member can gather advance stats])
- LB2_LINUX_TEST_RESULT([getattr_path], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'inode_operations' getattr member can gather advance stats],
+ [getattr_path], [
AC_DEFINE(HAVE_INODEOPS_ENHANCED_GETATTR, 1,
[inode_operations .getattr member function can gather advance stats])
])
])
])
AC_DEFUN([LC_VM_OPERATIONS_REMOVE_VMF_ARG], [
- AC_MSG_CHECKING([if 'struct vm_operations' removed struct vm_area_struct])
- LB2_LINUX_TEST_RESULT([vm_operations_no_vm_area_struct], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'struct vm_operations' removed struct vm_area_struct],
+ [vm_operations_no_vm_area_struct], [
AC_DEFINE(HAVE_VM_OPS_USE_VM_FAULT_ONLY, 1,
['struct vm_operations' remove struct vm_area_struct argument])
])
])
])
AC_DEFUN([LC_HAVE_KEY_USAGE_REFCOUNT], [
- AC_MSG_CHECKING([if 'key.usage' is refcount_t])
- LB2_LINUX_TEST_RESULT([key_usage_refcount], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'key.usage' is refcount_t],
+ [key_usage_refcount], [
AC_DEFINE(HAVE_KEY_USAGE_REFCOUNT, 1,
[key.usage is of type refcount_t])
])
])
])
AC_DEFUN([LC_HAVE_CRYPTO_MAX_ALG_NAME_128], [
- AC_MSG_CHECKING([if 'CRYPTO_MAX_ALG_NAME' is 128])
- LB2_LINUX_TEST_RESULT([crypto_max_alg_name], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'CRYPTO_MAX_ALG_NAME' is 128],
+ [crypto_max_alg_name], [
AC_DEFINE(HAVE_CRYPTO_MAX_ALG_NAME_128, 1,
['CRYPTO_MAX_ALG_NAME' is 128])
])
])
])
AC_DEFUN([LC_CURRENT_TIME], [
- AC_MSG_CHECKING([if CURRENT_TIME has been replaced with current_time])
- LB2_LINUX_TEST_RESULT([current_time], [
+ LB2_MSG_LINUX_TEST_RESULT([if CURRENT_TIME has been replaced with current_time],
+ [current_time], [
AC_DEFINE(HAVE_CURRENT_TIME, 1,
[current_time() has replaced CURRENT_TIME])
])
])
])
AC_DEFUN([LC_HAVE_GET_INODE_USAGE], [
- AC_MSG_CHECKING([if get_inode_usage exists])
- LB2_LINUX_TEST_RESULT([get_inode_usage], [
+ LB2_MSG_LINUX_TEST_RESULT([if get_inode_usage exists],
+ [get_inode_usage], [
AC_DEFINE(HAVE_GET_INODE_USAGE, 1,
[get_inode_usage function exists])
])
])
])
AC_DEFUN([LC_SUPER_SETUP_BDI_NAME], [
- AC_MSG_CHECKING([if 'super_setup_bdi_name' exist])
- LB2_LINUX_TEST_RESULT([super_setup_bdi_name], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'super_setup_bdi_name' exist],
+ [super_setup_bdi_name], [
AC_DEFINE(HAVE_SUPER_SETUP_BDI_NAME, 1,
['super_setup_bdi_name' is available])
])
])
])
AC_DEFUN([LC_BI_STATUS], [
- AC_MSG_CHECKING([if 'bi_status' exist])
- LB2_LINUX_TEST_RESULT([bi_status], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'bi_status' exist],
+ [bi_status], [
AC_DEFINE(HAVE_BI_STATUS, 1, ['bi_status' is available])
])
]) # LC_BI_STATUS
])
])
AC_DEFUN([LC_PAGEVEC_INIT_ONE_PARAM], [
- AC_MSG_CHECKING([if 'pagevec_init' takes one parameter])
- LB2_LINUX_TEST_RESULT([pagevec_init], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'pagevec_init' takes one parameter],
+ [pagevec_init], [
AC_DEFINE(HAVE_PAGEVEC_INIT_ONE_PARAM, 1,
['pagevec_init' takes one parameter])
])
])
])
AC_DEFUN([LC_BI_BDEV], [
- AC_MSG_CHECKING([if 'bi_bdev' exist])
- LB2_LINUX_TEST_RESULT([bi_bdev], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'bi_bdev' exist],
+ [bi_bdev], [
AC_DEFINE(HAVE_BI_BDEV, 1, ['bi_bdev' is available])
])
]) # LC_BI_BDEV
],[-Werror])
])
AC_DEFUN([LC_INTERVAL_TREE_CACHED], [
- AC_MSG_CHECKING([if interval_trees use rb_tree_cached])
- LB2_LINUX_TEST_RESULT([itree_cached], [
+ LB2_MSG_LINUX_TEST_RESULT([if interval_trees use rb_tree_cached],
+ [itree_cached], [
AC_DEFINE(HAVE_INTERVAL_TREE_CACHED, 1,
[interval trees use rb_tree_cached])
])
])
])
AC_DEFUN([LC_I_PAGES], [
- AC_MSG_CHECKING([if struct address_space has i_pages])
- LB2_LINUX_TEST_RESULT([i_pages], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct address_space has i_pages],
+ [i_pages], [
AC_DEFINE(HAVE_I_PAGES, 1, [struct address_space has i_pages])
])
]) # LC_I_PAGES
])
])
AC_DEFUN([LC_VM_FAULT_T], [
- AC_MSG_CHECKING([if vm_fault_t type exists])
- LB2_LINUX_TEST_RESULT([vm_fault_t], [
+ LB2_MSG_LINUX_TEST_RESULT([if vm_fault_t type exists],
+ [vm_fault_t], [
AC_DEFINE(HAVE_VM_FAULT_T, 1, [if vm_fault_t type exists])
])
]) # LC_VM_FAULT_T
])
])
AC_DEFUN([LC_VM_FAULT_RETRY], [
- AC_MSG_CHECKING([if VM_FAULT_RETRY is defined])
- LB2_LINUX_TEST_RESULT([VM_FAULT_RETRY], [
+ LB2_MSG_LINUX_TEST_RESULT([if VM_FAULT_RETRY is defined],
+ [VM_FAULT_RETRY], [
AC_DEFINE(HAVE_VM_FAULT_RETRY, 1,
[if VM_FAULT_RETRY is defined])
])
])
])
AC_DEFUN([LC_ALLOC_FILE_PSEUDO], [
- AC_MSG_CHECKING([if 'alloc_file_pseudo' is defined])
- LB2_LINUX_TEST_RESULT([alloc_file_pseudo], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'alloc_file_pseudo' is defined],
+ [alloc_file_pseudo], [
AC_DEFINE(HAVE_ALLOC_FILE_PSEUDO, 1,
['alloc_file_pseudo' exist])
])
],[-Werror])
])
AC_DEFUN([LC_INODE_TIMESPEC64], [
- AC_MSG_CHECKING([if inode timestamps are struct timespec64])
- LB2_LINUX_TEST_RESULT([inode_timespec64], [
+ LB2_MSG_LINUX_TEST_RESULT([if inode timestamps are struct timespec64],
+ [inode_timespec64], [
AC_DEFINE(HAVE_INODE_TIMESPEC64, 1,
[inode times are using timespec64])
])
],[-Werror])
])
AC_DEFUN([LC_RADIX_TREE_TAG_SET], [
- AC_MSG_CHECKING([if 'radix_tree_tag_set' exists])
- LB2_LINUX_TEST_RESULT([radix_tree_tag_set], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'radix_tree_tag_set' exists],
+ [radix_tree_tag_set], [
AC_DEFINE(HAVE_RADIX_TREE_TAG_SET, 1,
[radix_tree_tag_set exists])
])
],[-Werror])
])
AC_DEFUN([LC_UAPI_LINUX_MOUNT_H], [
- AC_MSG_CHECKING([if MS_RDONLY was moved to uapi/linux/mount.h])
- LB2_LINUX_TEST_RESULT([uapi_linux_mount], [
+ LB2_MSG_LINUX_TEST_RESULT([if MS_RDONLY was moved to uapi/linux/mount.h],
+ [uapi_linux_mount], [
AC_DEFINE(HAVE_UAPI_LINUX_MOUNT_H, 1,
[if MS_RDONLY was moved to uapi/linux/mount.h])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_SUNRPC_CACHE_HASH_LOCK_IS_A_SPINLOCK], [
- AC_MSG_CHECKING([if cache_detail->hash_lock is a spinlock])
- LB2_LINUX_TEST_RESULT([hash_lock_isa_spinlock_t], [
+ LB2_MSG_LINUX_TEST_RESULT([if cache_detail->hash_lock is a spinlock],
+ [hash_lock_isa_spinlock_t], [
AC_DEFINE(HAVE_CACHE_HASH_SPINLOCK, 1,
[if cache_detail->hash_lock is a spinlock])
])
],[-Werror])
])
AC_DEFUN([LC_GENL_FAMILY_HAS_RESV_START_OP], [
- AC_MSG_CHECKING([if struct genl_family has resv_start_op member])
- LB2_LINUX_TEST_RESULT([genl_family_has_resv_start_op], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct genl_family has resv_start_op member],
+ [genl_family_has_resv_start_op], [
AC_DEFINE(GENL_FAMILY_HAS_RESV_START_OP, 1,
[struct genl_family has resv_start_op member])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_BVEC_ITER_ALL], [
- AC_MSG_CHECKING([if bvec_iter_all exists for multi-page bvec iternation])
- LB2_LINUX_TEST_RESULT([struct_bvec_iter_all], [
+ LB2_MSG_LINUX_TEST_RESULT([if bvec_iter_all exists for multi-page bvec iternation],
+ [struct_bvec_iter_all], [
AC_DEFINE(HAVE_BVEC_ITER_ALL, 1,
[if bvec_iter_all exists for multi-page bvec iternation])
])
])
])
AC_DEFUN([LC_KEYRING_SEARCH_4ARGS], [
- AC_MSG_CHECKING([if 'keyring_search' has 4 args])
- LB2_LINUX_TEST_RESULT([keyring_search_4args], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'keyring_search' has 4 args],
+ [keyring_search_4args], [
AC_DEFINE(HAVE_KEYRING_SEARCH_4ARGS, 1,
[keyring_search has 4 args])
])
],[-Werror])
])
AC_DEFUN([LC_BIO_BI_PHYS_SEGMENTS], [
- AC_MSG_CHECKING([if struct bio has bi_phys_segments member])
- LB2_LINUX_TEST_RESULT([bye_bio_bi_phys_segments], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct bio has bi_phys_segments member],
+ [bye_bio_bi_phys_segments], [
AC_DEFINE(HAVE_BIO_BI_PHYS_SEGMENTS, 1,
[struct bio has bi_phys_segments member])
])
],[-Werror])
])
AC_DEFUN([LC_LM_COMPARE_OWNER_EXISTS], [
- AC_MSG_CHECKING([if lock_manager_operations has lm_compare_owner])
- LB2_LINUX_TEST_RESULT([lock_manager_ops_lm_compare_owner], [
+ LB2_MSG_LINUX_TEST_RESULT([if lock_manager_operations has lm_compare_owner],
+ [lock_manager_ops_lm_compare_owner], [
AC_DEFINE(HAVE_LM_COMPARE_OWNER, 1,
[lock_manager_operations has lm_compare_owner])
])
],[-Werror])
])
AC_DEFUN([LC_FSCRYPT_DIGESTED_NAME], [
- AC_MSG_CHECKING([if fscrypt has 'struct fscrypt_digested_name'])
- LB2_LINUX_TEST_RESULT([fscrypt_digested_name], [
+ LB2_MSG_LINUX_TEST_RESULT([if fscrypt has 'struct fscrypt_digested_name'],
+ [fscrypt_digested_name], [
AC_DEFINE(HAVE_FSCRYPT_DIGESTED_NAME, 1,
['struct fscrypt_digested_name' exists])
])
],[-Werror])
])
AC_DEFUN([LC_FSCRYPT_DUMMY_CONTEXT_ENABLED], [
- AC_MSG_CHECKING([if fscrypt_dummy_context_enabled() exists])
- LB2_LINUX_TEST_RESULT([fscrypt_dummy_context_enabled], [
+ LB2_MSG_LINUX_TEST_RESULT([if fscrypt_dummy_context_enabled() exists],
+ [fscrypt_dummy_context_enabled], [
AC_DEFINE(HAVE_FSCRYPT_DUMMY_CONTEXT_ENABLED, 1,
[fscrypt_dummy_context_enabled() exists])
])
],[-Werror])
])
AC_DEFUN([LC_FSCRYPT_FNAME_ALLOC_BUFFER], [
- AC_MSG_CHECKING([if fscrypt_fname_alloc_buffer() removed inode parameter])
- LB2_LINUX_TEST_RESULT([fscrypt_fname_alloc_buffer], [
+ LB2_MSG_LINUX_TEST_RESULT([if fscrypt_fname_alloc_buffer() removed inode parameter],
+ [fscrypt_fname_alloc_buffer], [
AC_DEFINE(HAVE_FSCRYPT_FNAME_ALLOC_BUFFER_NO_INODE, 1,
[fscrypt_fname_alloc_buffer() does not have inode parameter])
])
])
])
AC_DEFUN([LC_FSCRYPT_SET_CONTEXT], [
- AC_MSG_CHECKING([if 'fscrypt_set_context()' exists])
- LB2_LINUX_TEST_RESULT([fscrypt_set_context], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'fscrypt_set_context()' exists],
+ [fscrypt_set_context], [
AC_DEFINE(HAVE_FSCRYPT_SET_CONTEXT, 1,
[fscrypt_set_context() does exist])
])
],[-Werror])
])
AC_DEFUN([LC_FSCRYPT_NOKEY_NAME], [
- AC_MSG_CHECKING([if struct fscrypt_name has is_nokey_name field])
- LB2_LINUX_TEST_RESULT([fname_is_nokey_name], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct fscrypt_name has is_nokey_name field],
+ [fname_is_nokey_name], [
AC_DEFINE(HAVE_FSCRYPT_NOKEY_NAME, 1,
[struct fscrypt_name has is_nokey_name field])
])
],[-Werror])
])
AC_DEFUN([LC_FSCRYPT_SET_TEST_DUMMY_ENC_CHAR_ARG], [
- AC_MSG_CHECKING([if fscrypt_set_test_dummy_encryption() take 'const char' parameter])
- LB2_LINUX_TEST_RESULT([fscrypt_set_test_dummy_encryption], [
+ LB2_MSG_LINUX_TEST_RESULT([if fscrypt_set_test_dummy_encryption() take 'const char' parameter],
+ [fscrypt_set_test_dummy_encryption], [
AC_DEFINE(HAVE_FSCRYPT_SET_TEST_DUMMY_ENC_CHAR_ARG, 1,
[fscrypt_set_test_dummy_encryption() take 'const char' parameter])
])
],[-Werror])
])
AC_DEFUN([LC_FSCRYPT_DUMMY_POLICY], [
- AC_MSG_CHECKING([if fscrypt_free_dummy_policy() exists])
- LB2_LINUX_TEST_RESULT([fscrypt_free_dummy_policy], [
+ LB2_MSG_LINUX_TEST_RESULT([if fscrypt_free_dummy_policy() exists],
+ [fscrypt_free_dummy_policy], [
AC_DEFINE(HAVE_FSCRYPT_DUMMY_POLICY, 1,
[fscrypt_free_dummy_policy() exists])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_ITER_FILE_SPLICE_WRITE], [
- AC_MSG_CHECKING([if iter_file_splice_write() exists])
- LB2_LINUX_TEST_RESULT([iter_file_splice_write], [
+ LB2_MSG_LINUX_TEST_RESULT([if iter_file_splice_write() exists],
+ [iter_file_splice_write], [
AC_DEFINE(HAVE_ITER_FILE_SPLICE_WRITE, 1,
['iter_file_splice_write' exists])
])
],[-Werror])
])
AC_DEFUN([LC_FSCRYPT_IS_NOKEY_NAME], [
- AC_MSG_CHECKING([if fscrypt_is_no_key_name() exists])
- LB2_LINUX_TEST_RESULT([fscrypt_is_no_key_name], [
+ LB2_MSG_LINUX_TEST_RESULT([if fscrypt_is_no_key_name() exists],
+ [fscrypt_is_no_key_name], [
AC_DEFINE(HAVE_FSCRYPT_IS_NOKEY_NAME, 1,
[fscrypt_is_nokey_name() exists])
])
],[-Werror])
])
AC_DEFUN([LC_FSCRYPT_PREPARE_READDIR], [
- AC_MSG_CHECKING([if fscrypt_prepare_readdir() exists])
- LB2_LINUX_TEST_RESULT([fscrypt_prepare_readdir], [
+ LB2_MSG_LINUX_TEST_RESULT([if fscrypt_prepare_readdir() exists],
+ [fscrypt_prepare_readdir], [
AC_DEFINE(HAVE_FSCRYPT_PREPARE_READDIR, 1,
[fscrypt_prepare_readdir() exists])
])
],[-Werror])
])
AC_DEFUN([LC_BIO_SET_DEV], [
- AC_MSG_CHECKING([if 'bio_set_dev' is available])
- LB2_LINUX_TEST_RESULT([bio_set_dev], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'bio_set_dev' is available],
+ [bio_set_dev], [
AC_DEFINE(HAVE_BIO_SET_DEV, 1, ['bio_set_dev' is available])
])
]) # LC_BIO_SET_DEV
],[-Werror])
])
AC_DEFUN([LC_HAVE_USER_NAMESPACE_ARG], [
- AC_MSG_CHECKING([if 'inode_operations' members have user namespace argument])
- LB2_LINUX_TEST_RESULT([inode_ops_has_user_namespace_argument], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'inode_operations' members have user namespace argument],
+ [inode_ops_has_user_namespace_argument], [
AC_DEFINE(HAVE_USER_NAMESPACE_ARG, 1,
['inode_operations' members have user namespace argument])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_GET_ACL_RCU_ARG], [
- AC_MSG_CHECKING([if 'get_acl' has a rcu argument])
- LB2_LINUX_TEST_RESULT([get_acl_rcu_argument], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'get_acl' has a rcu argument],
+ [get_acl_rcu_argument], [
AC_DEFINE(HAVE_GET_ACL_RCU_ARG, 1,
['get_acl' has a rcu argument])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_SECURITY_DENTRY_INIT_WITH_XATTR_NAME_ARG], [
- AC_MSG_CHECKING([if security_dentry_init_security() returns xattr name])
- LB2_LINUX_TEST_RESULT([security_dentry_init_security_xattr_name_arg], [
+ LB2_MSG_LINUX_TEST_RESULT([if security_dentry_init_security() returns xattr name],
+ [security_dentry_init_security_xattr_name_arg], [
AC_DEFINE(HAVE_SECURITY_DENTRY_INIT_WITH_XATTR_NAME_ARG, 1,
[security_dentry_init_security() returns xattr name])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_KIOCB_COMPLETE_2ARGS], [
- AC_MSG_CHECKING([if kiocb->ki_complete() has 2 arguments])
- LB2_LINUX_TEST_RESULT([kiocb_ki_complete_2args], [
+ LB2_MSG_LINUX_TEST_RESULT([if kiocb->ki_complete() has 2 arguments],
+ [kiocb_ki_complete_2args], [
AC_DEFINE(HAVE_KIOCB_COMPLETE_2ARGS, 1,
[kiocb->ki_complete() has 2 arguments])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_INVALIDATE_FOLIO], [
- AC_MSG_CHECKING([if have address_spaace_operaions->invalidate_folio() member])
- LB2_LINUX_TEST_RESULT([address_spaace_operaions_invalidate_folio], [
+ LB2_MSG_LINUX_TEST_RESULT([if have address_spaace_operaions->invalidate_folio() member],
+ [address_spaace_operaions_invalidate_folio], [
AC_DEFINE(HAVE_INVALIDATE_FOLIO, 1,
[address_spaace_operaions->invalidate_folio() member exists])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_DIRTY_FOLIO], [
- AC_MSG_CHECKING([if have address_spaace_operaions->dirty_folio() member])
- LB2_LINUX_TEST_RESULT([address_spaace_operaions_dirty_folio], [
+ LB2_MSG_LINUX_TEST_RESULT([if have address_spaace_operaions->dirty_folio() member],
+ [address_spaace_operaions_dirty_folio], [
AC_DEFINE(HAVE_DIRTY_FOLIO, 1,
[address_spaace_operaions->dirty_folio() member exists])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_ALLOC_INODE_SB], [
- AC_MSG_CHECKING([if alloc_inode_sb() exists])
- LB2_LINUX_TEST_RESULT([alloc_inode_sb], [
+ LB2_MSG_LINUX_TEST_RESULT([if alloc_inode_sb() exists],
+ [alloc_inode_sb], [
AC_DEFINE(HAVE_ALLOC_INODE_SB, 1,
[alloc_inode_sb() exists])
])
],[-Werror])
])
AC_DEFUN([LC_GRAB_CACHE_PAGE_WRITE_BEGIN_WITH_FLAGS], [
- AC_MSG_CHECKING([if grab_cache_page_write_begin() has flags argument])
- LB2_LINUX_TEST_RESULT([grab_cache_page_write_begin_with_flags], [
+ LB2_MSG_LINUX_TEST_RESULT([if grab_cache_page_write_begin() has flags argument],
+ [grab_cache_page_write_begin_with_flags], [
AC_DEFINE(HAVE_GRAB_CACHE_PAGE_WRITE_BEGIN_WITH_FLAGS, 1,
[grab_cache_page_write_begin() has flags argument])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_ADDRESS_SPACE_OPERATIONS_READ_FOLIO], [
- AC_MSG_CHECKING([if struct address_space_operations() has read_folio()])
- LB2_LINUX_TEST_RESULT([address_space_operations_read_folio], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct address_space_operations() has read_folio()],
+ [address_space_operations_read_folio], [
AC_DEFINE(HAVE_AOPS_READ_FOLIO, 1,
[struct address_space_operations() has read_folio()])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_READ_CACHE_PAGE_FILLER_WITH_FILE], [
- AC_MSG_CHECKING([if read_cache_page() filler_t needs struct file])
- LB2_LINUX_TEST_RESULT([read_cache_page_filler_with_file], [
+ LB2_MSG_LINUX_TEST_RESULT([if read_cache_page() filler_t needs struct file],
+ [read_cache_page_filler_with_file], [
AC_DEFINE(HAVE_READ_CACHE_PAGE_WANTS_FILE, 1,
[read_cache_page() filler_t needs struct file])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_ADDRESS_SPACE_OPERATIONS_RELEASE_FOLIO], [
- AC_MSG_CHECKING([if struct address_space_operations() has release_folio()])
- LB2_LINUX_TEST_RESULT([address_space_operations_release_folio], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct address_space_operations() has release_folio()],
+ [address_space_operations_release_folio], [
AC_DEFINE(HAVE_AOPS_RELEASE_FOLIO, 1,
[struct address_space_operations() has release_folio()])
])
],[])
])
AC_DEFUN([LC_HAVE_LSMCONTEXT_INIT], [
- AC_MSG_CHECKING([if lsmcontext_init is available])
- LB2_LINUX_TEST_RESULT([lsmcontext_init], [
+ LB2_MSG_LINUX_TEST_RESULT([if lsmcontext_init is available],
+ [lsmcontext_init], [
AC_DEFINE(HAVE_LSMCONTEXT_INIT, 1,
[lsmcontext_init is available])
])
],[-Werror])
])
AC_DEFUN([LC_SECURITY_DENTRY_INIT_SECURTY_WITH_CTX], [
- AC_MSG_CHECKING([if security_dentry_init_security needs lsmcontext])
- LB2_LINUX_TEST_RESULT([security_dentry_init_security_with_ctx], [
+ LB2_MSG_LINUX_TEST_RESULT([if security_dentry_init_security needs lsmcontext],
+ [security_dentry_init_security_with_ctx], [
AC_DEFINE(HAVE_SECURITY_DENTRY_INIT_SECURTY_WITH_CTX, 1,
[security_dentry_init_security needs lsmcontext])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_NO_LLSEEK], [
- AC_MSG_CHECKING([if no_llseek() is available])
- LB2_LINUX_TEST_RESULT([no_llseek], [
+ LB2_MSG_LINUX_TEST_RESULT([if no_llseek() is available],
+ [no_llseek], [
AC_DEFINE(HAVE_NO_LLSEEK, 1, [no_llseek() is available])
])
]) # LC_HAVE_NO_LLSEEK
],[-Werror])
])
AC_DEFUN([LC_DQUOT_TRANSFER_WITH_USER_NS], [
- AC_MSG_CHECKING([if dquot_transfer() has user_ns argument])
- LB2_LINUX_TEST_RESULT([dquot_transfer], [
+ LB2_MSG_LINUX_TEST_RESULT([if dquot_transfer() has user_ns argument],
+ [dquot_transfer], [
AC_DEFINE(HAVE_DQUOT_TRANSFER_WITH_USER_NS, 1,
[dquot_transfer() has user_ns argument])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_ADDRESS_SPACE_OPERATIONS_MIGRATE_FOLIO], [
- AC_MSG_CHECKING([if struct address_space_operations() has migrate_folio()])
- LB2_LINUX_TEST_RESULT([address_space_operations_migrate_folio], [
+ LB2_MSG_LINUX_TEST_RESULT([if struct address_space_operations() has migrate_folio()],
+ [address_space_operations_migrate_folio], [
AC_DEFINE(HAVE_AOPS_MIGRATE_FOLIO, 1,
[struct address_space_operations() has migrate_folio()])
])
],[-Werror])
])
AC_DEFUN([LC_REGISTER_SHRINKER_FORMAT_NAMED], [
- AC_MSG_CHECKING([if register_shrinker() returns status])
- LB2_LINUX_TEST_RESULT([register_shrinker_format], [
+ LB2_MSG_LINUX_TEST_RESULT([if register_shrinker() returns status],
+ [register_shrinker_format], [
AC_DEFINE(HAVE_REGISTER_SHRINKER_FORMAT_NAMED, 1,
[register_shrinker() returns status])
])
],[-Werror])
]) # LC_HAVE_VFS_SETXATTR_NON_CONST_VALUE
AC_DEFUN([LC_HAVE_VFS_SETXATTR_NON_CONST_VALUE], [
- AC_MSG_CHECKING([if vfs_setxattr() value argument is non-const])
- LB2_LINUX_TEST_RESULT([vfs_setxattr_non_const_value_arg], [
+ LB2_MSG_LINUX_TEST_RESULT([if vfs_setxattr() value argument is non-const],
+ [vfs_setxattr_non_const_value_arg], [
AC_DEFINE([VFS_SETXATTR_VALUE(value)],
[(value)],
[vfs_setxattr() value argument is const void *])
],[-Werror])
])
AC_DEFUN([LC_HAVE_IOV_ITER_GET_PAGES_ALLOC2], [
- AC_MSG_CHECKING([if iov_iter_get_pages_alloc2() is available])
- LB2_LINUX_TEST_RESULT([iov_iter_get_pages_alloc2], [
+ LB2_MSG_LINUX_TEST_RESULT([if iov_iter_get_pages_alloc2() is available],
+ [iov_iter_get_pages_alloc2], [
AC_DEFINE(HAVE_IOV_ITER_GET_PAGES_ALLOC2, 1,
[iov_iter_get_pages_alloc2() is available])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_GET_RANDOM_U32_AND_U64], [
- AC_MSG_CHECKING([if get_random_u32() and get_random_u64() are available])
- LB2_LINUX_TEST_RESULT([get_random_u32_and_u64], [
+ LB2_MSG_LINUX_TEST_RESULT([if get_random_u32() and get_random_u64() are available],
+ [get_random_u32_and_u64], [
AC_DEFINE(HAVE_GET_RANDOM_U32_AND_U64, 1,
[get_random_[u32|u64] are available])
],[
],[-Werror])
])
AC_DEFUN([LC_NFS_FILLDIR_USE_CTX_RETURN_BOOL], [
- AC_MSG_CHECKING([if filldir_t uses struct dir_context and returns bool])
- LB2_LINUX_TEST_RESULT([filldir_ctx_return_bool], [
+ LB2_MSG_LINUX_TEST_RESULT([if filldir_t uses struct dir_context and returns bool],
+ [filldir_ctx_return_bool], [
AC_DEFINE(HAVE_FILLDIR_USE_CTX_RETURN_BOOL, 1,
[filldir_t needs struct dir_context and returns bool])
AC_DEFINE(HAVE_FILLDIR_USE_CTX, 1,
],[-Werror])
])
AC_DEFUN([LC_HAVE_FILEMAP_GET_FOLIOS_CONTIG], [
- AC_MSG_CHECKING([if filemap_get_folios_contig() is available])
- LB2_LINUX_TEST_RESULT([filemap_get_folios_contig], [
+ LB2_MSG_LINUX_TEST_RESULT([if filemap_get_folios_contig() is available],
+ [filemap_get_folios_contig], [
AC_DEFINE(HAVE_FILEMAP_GET_FOLIOS_CONTIG, 1,
[filemap_get_folios_contig() is available])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_GET_RANDOM_U32_BELOW], [
- AC_MSG_CHECKING([if get_random_u32_below()is available])
- LB2_LINUX_TEST_RESULT([get_random_u32_below], [
+ LB2_MSG_LINUX_TEST_RESULT([if get_random_u32_below()is available],
+ [get_random_u32_below], [
AC_DEFINE(HAVE_GET_RANDOM_U32_BELOW, 1,
[get_random_u32_below() is available])
],[
],[-Werror])
])
AC_DEFUN([LC_HAVE_ACL_WITH_DENTRY], [
- AC_MSG_CHECKING([if 'get_acl' and 'set_acl' use dentry argument])
- LB2_LINUX_TEST_RESULT([acl_with_dentry], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'get_acl' and 'set_acl' use dentry argument],
+ [acl_with_dentry], [
AC_DEFINE(HAVE_ACL_WITH_DENTRY, 1,
['get_acl' and 'set_acl' use dentry argument])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_U64_CAPABILITY], [
- AC_MSG_CHECKING([if 'kernel_cap_t' has u64 val])
- LB2_LINUX_TEST_RESULT([kernel_cap_t_has_u64_value], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'kernel_cap_t' has u64 val],
+ [kernel_cap_t_has_u64_value], [
AC_DEFINE(HAVE_U64_CAPABILITY, 1,
['kernel_cap_t' has u64 val])
])
],[-Werror])
])
AC_DEFUN([LC_HAVE_MNT_IDMAP_ARG], [
- AC_MSG_CHECKING([if 'inode_operations' members have mnt_idmap argument])
- LB2_LINUX_TEST_RESULT([inode_ops_getattr_has_mnt_idmap_argument], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'inode_operations' members have mnt_idmap argument],
+ [inode_ops_getattr_has_mnt_idmap_argument], [
AC_DEFINE(HAVE_MNT_IDMAP_ARG, 1,
['inode_operations' members have mnt_idmap argument])
AC_DEFINE(HAVE_USER_NAMESPACE_ARG, 1,
])
])
AC_DEFUN([LC_HAVE_LOCKS_LOCK_FILE_WAIT_IN_FILELOCK], [
- AC_MSG_CHECKING([if 'locks_lock_file_wait' exists in filelock.h])
- LB2_LINUX_TEST_RESULT([locks_lock_file_wait_in_filelock], [
+ LB2_MSG_LINUX_TEST_RESULT([if 'locks_lock_file_wait' exists in filelock.h],
+ [locks_lock_file_wait_in_filelock], [
AC_DEFINE(HAVE_LOCKS_LOCK_FILE_WAIT, 1,
[kernel has locks_lock_file_wait in filelock.h])
AC_DEFINE(HAVE_LINUX_FILELOCK_HEADER, 1,
git://git.whamcloud.com / fs / lustre-release.git / commitdiff