X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=libcfs%2Fautoconf%2Flustre-libcfs.m4;h=4774cac789354f6a84f702cc9edf7cef4d106826;hp=d764b236720fe0be35ade5f2946b8fb7b8ef3240;hb=e37335b2d8c2dc74badea8978ab3f46a63621265;hpb=26008f505c57a7affa4d12b542d3d5a790d7e69a diff --git a/libcfs/autoconf/lustre-libcfs.m4 b/libcfs/autoconf/lustre-libcfs.m4 index d764b23..4774cac 100644 --- a/libcfs/autoconf/lustre-libcfs.m4 +++ b/libcfs/autoconf/lustre-libcfs.m4 @@ -1,911 +1,1057 @@ # -# LN_CONFIG_CDEBUG +# LIBCFS_CONFIG_CDEBUG # # whether to enable various libcfs debugs (CDEBUG, ENTRY/EXIT, LASSERT, etc.) # -AC_DEFUN([LN_CONFIG_CDEBUG], -[ +AC_DEFUN([LIBCFS_CONFIG_CDEBUG], [ AC_MSG_CHECKING([whether to enable CDEBUG, CWARN]) AC_ARG_ENABLE([libcfs_cdebug], AC_HELP_STRING([--disable-libcfs-cdebug], - [disable libcfs CDEBUG, CWARN]), - [],[enable_libcfs_cdebug='yes']) + [disable libcfs CDEBUG, CWARN]), + [], [enable_libcfs_cdebug="yes"]) AC_MSG_RESULT([$enable_libcfs_cdebug]) -if test x$enable_libcfs_cdebug = xyes; then - AC_DEFINE(CDEBUG_ENABLED, 1, [enable libcfs CDEBUG, CWARN]) -else - AC_DEFINE(CDEBUG_ENABLED, 0, [disable libcfs CDEBUG, CWARN]) -fi +AS_IF([test "x$enable_libcfs_cdebug" = xyes], + [AC_DEFINE(CDEBUG_ENABLED, 1, [enable libcfs CDEBUG, CWARN])]) AC_MSG_CHECKING([whether to enable ENTRY/EXIT]) AC_ARG_ENABLE([libcfs_trace], AC_HELP_STRING([--disable-libcfs-trace], - [disable libcfs ENTRY/EXIT]), - [],[enable_libcfs_trace='yes']) + [disable libcfs ENTRY/EXIT]), + [], [enable_libcfs_trace="yes"]) AC_MSG_RESULT([$enable_libcfs_trace]) -if test x$enable_libcfs_trace = xyes; then - AC_DEFINE(CDEBUG_ENTRY_EXIT, 1, [enable libcfs ENTRY/EXIT]) -else - AC_DEFINE(CDEBUG_ENTRY_EXIT, 0, [disable libcfs ENTRY/EXIT]) -fi +AS_IF([test "x$enable_libcfs_trace" = xyes], + [AC_DEFINE(CDEBUG_ENTRY_EXIT, 1, [enable libcfs ENTRY/EXIT])]) AC_MSG_CHECKING([whether to enable LASSERT, LASSERTF]) AC_ARG_ENABLE([libcfs_assert], AC_HELP_STRING([--disable-libcfs-assert], - [disable libcfs LASSERT, LASSERTF]), - [],[enable_libcfs_assert='yes']) + [disable libcfs LASSERT, LASSERTF]), + [], [enable_libcfs_assert="yes"]) AC_MSG_RESULT([$enable_libcfs_assert]) -if test x$enable_libcfs_assert = xyes; then - AC_DEFINE(LIBCFS_DEBUG, 1, [enable libcfs LASSERT, LASSERTF]) -fi -]) +AS_IF([test x$enable_libcfs_assert = xyes], + [AC_DEFINE(LIBCFS_DEBUG, 1, [enable libcfs LASSERT, LASSERTF])]) +]) # LIBCFS_CONFIG_CDEBUG # # LIBCFS_CONFIG_PANIC_DUMPLOG # # check if tunable panic_dumplog is wanted # -AC_DEFUN([LIBCFS_CONFIG_PANIC_DUMPLOG], -[AC_MSG_CHECKING([for tunable panic_dumplog support]) +AC_DEFUN([LIBCFS_CONFIG_PANIC_DUMPLOG], [ +AC_MSG_CHECKING([whether to use tunable 'panic_dumplog' support]) AC_ARG_ENABLE([panic_dumplog], - AC_HELP_STRING([--enable-panic_dumplog], - [enable panic_dumplog]), - [],[enable_panic_dumplog='no']) -if test x$enable_panic_dumplog = xyes ; then - AC_DEFINE(LNET_DUMP_ON_PANIC, 1, [use dumplog on panic]) - AC_MSG_RESULT([yes (by request)]) -else - AC_MSG_RESULT([no]) -fi -]) + AC_HELP_STRING([--enable-panic_dumplog], + [enable panic_dumplog]), + [], [enable_panic_dumplog="no"]) +AC_MSG_RESULT([$enable_panic_dumplog]) +AS_IF([test "x$enable_panic_dumplog" = xyes], + [AC_DEFINE(LNET_DUMP_ON_PANIC, 1, [use dumplog on panic])]) +]) # LIBCFS_CONFIG_PANIC_DUMPLOG # -# LIBCFS_STRUCT_PAGE_LIST +# LIBCFS_STACKTRACE_OPS_HAVE_WALK_STACK # -# 2.6.4 no longer has page->list +# 2.6.32-30.el6 adds a new 'walk_stack' field in 'struct stacktrace_ops' # -AC_DEFUN([LIBCFS_STRUCT_PAGE_LIST], -[AC_MSG_CHECKING([if struct page has a list field]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - struct page page; - &page.list; +AC_DEFUN([LIBCFS_STACKTRACE_OPS_HAVE_WALK_STACK], [ +LB_CHECK_COMPILE([if 'struct stacktrace_ops' has 'walk_stack' field], +stacktrace_ops_walk_stack, [ + #include ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_PAGE_LIST, 1, [struct page has a list field]) + ((struct stacktrace_ops *)0)->walk_stack(NULL, NULL, 0, NULL, NULL, NULL, NULL); ],[ - AC_MSG_RESULT([no]) -]) + AC_DEFINE(STACKTRACE_OPS_HAVE_WALK_STACK, 1, + ['struct stacktrace_ops' has 'walk_stack' field]) ]) +]) # LIBCFS_STACKTRACE_OPS_HAVE_WALK_STACK # -# LIBCFS_STRUCT_SIGHAND +# LIBCFS_STACKTRACE_WARNING # -# red hat 2.4 adds sighand to struct task_struct +# 3.0 removes stacktrace_ops warning* functions # -AC_DEFUN([LIBCFS_STRUCT_SIGHAND], -[AC_MSG_CHECKING([if task_struct has a sighand field]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - struct task_struct p; - p.sighand = NULL; +AC_DEFUN([LIBCFS_STACKTRACE_WARNING], [ +LB_CHECK_COMPILE([if 'stacktrace_ops.warning' is exist], +stacktrace_ops_warning, [ + struct task_struct; + struct pt_regs; + #include ],[ - AC_DEFINE(CONFIG_RH_2_4_20, 1, [this kernel contains Red Hat 2.4.20 patches]) - AC_MSG_RESULT([yes]) + ((struct stacktrace_ops *)0)->warning(NULL, NULL); ],[ - AC_MSG_RESULT([no]) + AC_DEFINE(HAVE_STACKTRACE_WARNING, 1, + [stacktrace_ops.warning is exist]) ]) +]) # LIBCFS_STACKTRACE_WARNING + +# +# LIBCFS_REINIT_COMPLETION +# +AC_DEFUN([LIBCFS_REINIT_COMPLETION], [ +LB_CHECK_COMPILE([if 'reinit_completion' exists], +reinit_completion, [ + #include +],[ + struct completion x; + reinit_completion(&x); +],[ + AC_DEFINE(HAVE_REINIT_COMPLETION, 1, + [reinit_completion is exist]) ]) +]) # LIBCFS_REINIT_COMPLETION # -# LIBCFS_FUNC_CPU_ONLINE +# LC_SHRINKER_WANT_SHRINK_PTR # -# cpu_online is different in rh 2.4, vanilla 2.4, and 2.6 +# RHEL6/2.6.32 want to have pointer to shrinker self pointer in handler function # -AC_DEFUN([LIBCFS_FUNC_CPU_ONLINE], -[AC_MSG_CHECKING([if kernel defines cpu_online()]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - cpu_online(0); +AC_DEFUN([LC_SHRINKER_WANT_SHRINK_PTR], [ +LB_CHECK_COMPILE([if 'shrinker' want self pointer in handler], +shrink_self_pointer, [ + #include ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_CPU_ONLINE, 1, [cpu_online found]) + struct shrinker *tmp = NULL; + tmp->shrink(tmp, 0, 0); ],[ - AC_MSG_RESULT([no]) -]) + AC_DEFINE(HAVE_SHRINKER_WANT_SHRINK_PTR, 1, + [shrinker want self pointer in handler]) ]) +]) # LC_SHRINKER_WANT_SHRINK_PTR # -# LIBCFS_TYPE_GFP_T +# LIBCFS_SYSCTL_CTLNAME # -# check if gfp_t is typedef-ed +# 2.6.33 no longer has ctl_name & strategy field in struct ctl_table. # -AC_DEFUN([LIBCFS_TYPE_GFP_T], -[AC_MSG_CHECKING([if kernel defines gfp_t]) -LB_LINUX_TRY_COMPILE([ - #include +AC_DEFUN([LIBCFS_SYSCTL_CTLNAME], [ +LB_CHECK_COMPILE([if 'ctl_table' has a 'ctl_name' field], +ctl_table_ctl_name, [ + #include ],[ - return sizeof(gfp_t); + struct ctl_table ct; + ct.ctl_name = sizeof(ct); ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_GFP_T, 1, [gfp_t found]) -],[ - AC_MSG_RESULT([no]) -]) + AC_DEFINE(HAVE_SYSCTL_CTLNAME, 1, + [ctl_table has ctl_name field]) ]) +]) # LIBCFS_SYSCTL_CTLNAME # -# LIBCFS_TYPE_CPUMASK_T +# LIBCFS_MODULE_LOCKING # -# same goes for cpumask_t +# 2.6.36 introduced locking to module params. RHEL6 lacks this support # -AC_DEFUN([LIBCFS_TYPE_CPUMASK_T], -[AC_MSG_CHECKING([if kernel defines cpumask_t]) -LB_LINUX_TRY_COMPILE([ - #include +AC_DEFUN([LIBCFS_MODULE_LOCKING],[ +LB_CHECK_COMPILE([does the kernel support module param locking], +module_param_locking, [ + #include ],[ - return sizeof (cpumask_t); + __kernel_param_lock(NULL); + __kernel_param_unlock(NULL); ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_CPUMASK_T, 1, [cpumask_t found]) -],[ - AC_MSG_RESULT([no]) -]) + AC_DEFINE(HAVE_MODULE_PARAM_LOCKING, 1, + [locking module param is supported]) ]) +]) # LIBCFS_MODULE_LOCKING # -# LIBCFS_FUNC_SHOW_TASK +# LIBCFS_KSTRTOUL # -# we export show_task(), but not all kernels have it (yet) +# 2.6.38 kstrtoul is added # -AC_DEFUN([LIBCFS_FUNC_SHOW_TASK], -[LB_CHECK_SYMBOL_EXPORT([show_task], -[kernel/ksyms.c kernel/sched.c],[ -AC_DEFINE(HAVE_SHOW_TASK, 1, [show_task is exported]) +AC_DEFUN([LIBCFS_KSTRTOUL], [ +LB_CHECK_COMPILE([if Linux kernel has 'kstrtoul'], +kstrtoul, [ + #include ],[ + unsigned long result; + return kstrtoul("12345", 0, &result); +],[ + AC_DEFINE(HAVE_KSTRTOUL, 1, + [kernel has kstrtoul]) ]) -]) +]) # LIBCFS_KSTRTOUL -# check userland & kernel __u64 type -AC_DEFUN([LIBCFS_U64_LONG_LONG], -[AC_MSG_CHECKING([u64 is long long type]) -tmp_flags="$CFLAGS" -CFLAGS="$CFLAGS -Werror" -AC_COMPILE_IFELSE([ - #include - #include - int main(void) { - unsigned long long *data1; - __u64 *data2 = NULL; - - data1 = data2; - return 0; - } +# +# LIBCFS_DUMP_TRACE_ADDRESS +# +# 2.6.39 adds a base pointer address argument to dump_trace +# +AC_DEFUN([LIBCFS_DUMP_TRACE_ADDRESS], [ +LB_CHECK_COMPILE([if 'dump_trace' want address], +dump_trace_address, [ + struct task_struct; + struct pt_regs; + #include ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_USER__U64_LONG_LONG, 1, - [__u64 is long long type]) + dump_trace(NULL, NULL, NULL, 0, NULL, NULL); ],[ - AC_MSG_RESULT([no]) + AC_DEFINE(HAVE_DUMP_TRACE_ADDRESS, 1, + [dump_trace want address argument]) ]) -CFLAGS="$tmp_flags" -AC_MSG_CHECKING([kernel __u64 is long long type]) -tmp_flags="$EXTRA_KCFLAGS" -EXTRA_KCFLAGS="$EXTRA_KCFLAGS -Werror" -LB_LINUX_TRY_COMPILE([ - #include - #include -],[ - unsigned long long *data1; - __u64 *data2 = NULL; +]) # LIBCFS_DUMP_TRACE_ADDRESS - data1 = data2; +# +# LC_SHRINK_CONTROL +# +# FC15 2.6.40-5 backported the "shrink_control" parameter to the memory +# pressure shrinker from Linux 3.0 +# +AC_DEFUN([LC_SHRINK_CONTROL], [ +LB_CHECK_COMPILE([if 'shrink_control' is present], +shrink_control, [ + #include + #include ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_KERN__U64_LONG_LONG, 1, - [kernel __u64 is long long type]) + struct shrink_control tmp = {0}; + tmp.nr_to_scan = sizeof(tmp); ],[ - AC_MSG_RESULT([no]) -]) -EXTRA_KCFLAGS="$tmp_flags" + AC_DEFINE(HAVE_SHRINK_CONTROL, 1, + [shrink_control is present]) ]) +]) # LC_SHRINK_CONTROL -# check if task_struct with rcu memeber -AC_DEFUN([LIBCFS_TASK_RCU], -[AC_MSG_CHECKING([if task_struct has a rcu field]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - struct task_struct tsk; +# +# LIBCFS_PROCESS_NAMESPACE +# +# 3.5 introduced process namespace +AC_DEFUN([LIBCFS_PROCESS_NAMESPACE], [ +LB_CHECK_LINUX_HEADER([linux/uidgid.h], [ + AC_DEFINE(HAVE_UIDGID_HEADER, 1, + [uidgid.h is present])]) +]) # LIBCFS_PROCESS_NAMESPACE - tsk.rcu.next = NULL; +# +# LIBCFS_I_UID_READ +# +# 3.5 added helpers to read the new uid/gid types from VFS structures +# SLE11 SP3 has uidgid.h but not the helpers +# +AC_DEFUN([LIBCFS_I_UID_READ], [ +LB_CHECK_COMPILE([if 'i_uid_read' is present], +i_uid_read, [ + #include ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_TASK_RCU, 1, - [task_struct has rcu field]) + i_uid_read(NULL); ],[ - AC_MSG_RESULT([no]) -]) + AC_DEFINE(HAVE_I_UID_READ, 1, [i_uid_read is present]) ]) +]) # LIBCFS_I_UID_READ -# LIBCFS_TASKLIST_LOCK -# 2.6.18 remove tasklist_lock export -AC_DEFUN([LIBCFS_TASKLIST_LOCK], -[LB_CHECK_SYMBOL_EXPORT([tasklist_lock], -[kernel/fork.c],[ -AC_DEFINE(HAVE_TASKLIST_LOCK, 1, - [tasklist_lock exported]) -],[ -]) -]) +# +# LIBCFS_HAVE_CRC32 +# +AC_DEFUN([LIBCFS_HAVE_CRC32], [ +LB_CHECK_CONFIG_IM([CRC32], + [have_crc32="yes"], [have_crc32="no"]) +AS_IF([test "x$have_crc32" = xyes], + [AC_DEFINE(HAVE_CRC32, 1, + [kernel compiled with CRC32 functions])]) +]) # LIBCFS_HAVE_CRC32 -# 2.6.19 API changes -# kmem_cache_destroy(cachep) return void instead of -# int -AC_DEFUN([LIBCFS_KMEM_CACHE_DESTROY_INT], -[AC_MSG_CHECKING([kmem_cache_destroy(cachep) return int]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - int i = kmem_cache_destroy(NULL); +# +# LIBCFS_ENABLE_CRC32_ACCEL +# +AC_DEFUN([LIBCFS_ENABLE_CRC32_ACCEL], [ +LB_CHECK_CONFIG_IM([CRYPTO_CRC32_PCLMUL], + [enable_crc32_crypto="no"], [enable_crc32_crypto="yes"]) +AS_IF([test "x$have_crc32" = xyes -a "x$enable_crc32_crypto" = xyes], [ + AC_DEFINE(NEED_CRC32_ACCEL, 1, [need pclmulqdq based crc32]) + AC_MSG_WARN([No crc32 pclmulqdq crypto api found, enable internal pclmulqdq based crc32])]) +]) # LIBCFS_ENABLE_CRC32_ACCEL + +# +# LIBCFS_ENABLE_CRC32C_ACCEL +# +AC_DEFUN([LIBCFS_ENABLE_CRC32C_ACCEL], [ +LB_CHECK_CONFIG_IM([CRYPTO_CRC32C_INTEL], + [enable_crc32c_crypto="no"], [enable_crc32c_crypto="yes"]) +AS_IF([test "x$enable_crc32c_crypto" = xyes], [ + AC_DEFINE(NEED_CRC32C_ACCEL, 1, [need pclmulqdq based crc32c]) + AC_MSG_WARN([No crc32c pclmulqdq crypto api found, enable internal pclmulqdq based crc32c])]) +]) # LIBCFS_ENABLE_CRC32C_ACCEL + +# +# Kernel version 3.11 introduced ktime_get_ts64 +# +AC_DEFUN([LIBCFS_KTIME_GET_TS64],[ +LB_CHECK_COMPILE([does function 'ktime_get_ts64' exist], +ktime_get_ts64, [ + #include + #include ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_KMEM_CACHE_DESTROY_INT, 1, - [kmem_cache_destroy(cachep) return int]) + struct timespec64 *ts = NULL; + + ktime_get_ts64(ts); ],[ - AC_MSG_RESULT(NO) -]) + AC_DEFINE(HAVE_KTIME_GET_TS64, 1, + ['ktime_get_ts64' is available]) ]) +]) # LIBCFS_KTIME_GET_TS64 -# 2.6.19 API change -#panic_notifier_list use atomic_notifier operations # -AC_DEFUN([LIBCFS_ATOMIC_PANIC_NOTIFIER], -[AC_MSG_CHECKING([panic_notifier_list is atomic]) -LB_LINUX_TRY_COMPILE([ - #include - #include -],[ - struct atomic_notifier_head panic_notifier_list; +# Linux kernel 3.12 introduced struct kernel_param_ops +# This has been backported to all lustre supported +# clients except RHEL6. We have to handle the differences. +# +AC_DEFUN([LIBCFS_KERNEL_PARAM_OPS],[ +LB_CHECK_COMPILE([does 'struct kernel_param_ops' exist], +kernel_param_ops, [ + #include ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_ATOMIC_PANIC_NOTIFIER, 1, - [panic_notifier_list is atomic_notifier_head]) + struct kernel_param_ops ops; + + ops.set = NULL; ],[ - AC_MSG_RESULT(NO) -]) + AC_DEFINE(HAVE_KERNEL_PARAM_OPS, 1, + ['struct kernel_param_ops' is available]) ]) +]) # LIBCFS_KERNEL_PARAM_OPS -# since 2.6.19 nlmsg_multicast() needs 5 argument. -AC_DEFUN([LIBCFS_NLMSG_MULTICAST], -[AC_MSG_CHECKING([nlmsg_multicast needs 5 argument]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - nlmsg_multicast(NULL, NULL, 0, 0, 0); +# +# Kernel version 3.12 introduced ktime_add +# +AC_DEFUN([LIBCFS_KTIME_ADD],[ +LB_CHECK_COMPILE([does function 'ktime_add' exist], +ktime_add, [ + #include + #include ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_NLMSG_MULTICAST_5ARGS, 1, - [nlmsg_multicast needs 5 argument]) + ktime_t start = ktime_set(0, 0); + ktime_t end = start; + ktime_t total; + + total = ktime_add(start, end); ],[ - AC_MSG_RESULT(NO) -]) + AC_DEFINE(HAVE_KTIME_ADD, 1, + [ktime_add is available]) ]) +]) # LIBCFS_KTIME_ADD # -# LIBCFS_NETLINK +# Kernel version 3.12 introduced ktime_after # -# If we have netlink.h, and nlmsg_new takes 2 args (2.6.19) -# -AC_DEFUN([LIBCFS_NETLINK], -[AC_MSG_CHECKING([if netlink.h can be compiled]) -LB_LINUX_TRY_COMPILE([ - #include -],[],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_NETLINK, 1, [net/netlink.h found]) +AC_DEFUN([LIBCFS_KTIME_AFTER],[ +LB_CHECK_COMPILE([does function 'ktime_after' exist], +ktime_after, [ + #include + #include +],[ + ktime_t start = ktime_set(0, 0); + ktime_t end = start; - AC_MSG_CHECKING([if nlmsg_new takes a 2nd argument]) - LB_LINUX_TRY_COMPILE([ - #include - ],[ - nlmsg_new(100, GFP_KERNEL); - ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_NETLINK_NL2, 1, [nlmsg_new takes 2 args]) - ],[ - AC_MSG_RESULT([no]) - ]) + ktime_after(start, end); ],[ - AC_MSG_RESULT([no]) -]) + AC_DEFINE(HAVE_KTIME_AFTER, 1, + [ktime_after is available]) ]) +]) # LIBCFS_KTIME_AFTER -# 2.6.20 API change INIT_WORK use 2 args and not -# store data inside -AC_DEFUN([LIBCFS_3ARGS_INIT_WORK], -[AC_MSG_CHECKING([check INIT_WORK want 3 args]) -LB_LINUX_TRY_COMPILE([ - #include +# +# Kernel version 3.12 introduced ktime_before +# See linux commit 67cb9366ff5f99868100198efba5ca88aaa6ad25 +# +AC_DEFUN([LIBCFS_KTIME_BEFORE],[ +LB_CHECK_COMPILE([does function 'ktime_before' exist], +ktime_before, [ + #include + #include ],[ - struct work_struct work; + ktime_t start = ktime_set(0, 0); + ktime_t end = start; - INIT_WORK(&work, NULL, NULL); -],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_3ARGS_INIT_WORK, 1, - [INIT_WORK use 3 args and store data inside]) + ktime_before(start, end); ],[ - AC_MSG_RESULT(NO) -]) + AC_DEFINE(HAVE_KTIME_BEFORE, 1, + [ktime_before is available]) ]) +]) # LIBCFS_KTIME_BEFORE -# 2.6.21 api change. 'register_sysctl_table' use only one argument, -# instead of more old which need two. -AC_DEFUN([LIBCFS_2ARGS_REGISTER_SYSCTL], -[AC_MSG_CHECKING([check register_sysctl_table want 2 args]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - return register_sysctl_table(NULL,0); +# +# Kernel version 3.12 introduced ktime_compare +# +AC_DEFUN([LIBCFS_KTIME_COMPARE],[ +LB_CHECK_COMPILE([does function 'ktime_compare' exist], +ktime_compare, [ + #include + #include ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_2ARGS_REGISTER_SYSCTL, 1, - [register_sysctl_table want 2 args]) + ktime_t start = ktime_set(0, 0); + ktime_t end = start; + + ktime_compare(start, end); ],[ - AC_MSG_RESULT(NO) -]) + AC_DEFINE(HAVE_KTIME_COMPARE, 1, + [ktime_compare is available]) ]) +]) # LIBCFS_KTIME_COMPARE -# 2.6.21 marks kmem_cache_t deprecated and uses struct kmem_cache -# instead -AC_DEFUN([LIBCFS_KMEM_CACHE], -[AC_MSG_CHECKING([check kernel has struct kmem_cache]) -tmp_flags="$EXTRA_KCFLAGS" -EXTRA_KCFLAGS="-Werror" -LB_LINUX_TRY_COMPILE([ - #include - typedef struct kmem_cache cache_t; +# +# FC19 3.12 kernel struct shrinker change +# +AC_DEFUN([LIBCFS_SHRINKER_COUNT],[ +LB_CHECK_COMPILE([shrinker has 'count_objects'], +shrinker_count_objects, [ + #include + #include ],[ - cache_t *cachep = NULL; + struct shrinker shrinker; - kmem_cache_alloc(cachep, 0); + shrinker.count_objects = NULL; ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_KMEM_CACHE, 1, - [kernel has struct kmem_cache]) -],[ - AC_MSG_RESULT(NO) -]) -EXTRA_KCFLAGS="$tmp_flags" + AC_DEFINE(HAVE_SHRINKER_COUNT, 1, + [shrinker has count_objects member]) ]) +]) # LIBCFS_SHRINKER_COUNT -# 2.6.23 lost dtor argument -AC_DEFUN([LIBCFS_KMEM_CACHE_CREATE_DTOR], -[AC_MSG_CHECKING([check kmem_cache_create has dtor argument]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - kmem_cache_create(NULL, 0, 0, 0, NULL, NULL); +# +# Kernel version 3.17 changed hlist_add_after to +# hlist_add_behind +# +AC_DEFUN([LIBCFS_HLIST_ADD_AFTER],[ +LB_CHECK_COMPILE([does function 'hlist_add_after' exist], +hlist_add_after, [ + #include ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_KMEM_CACHE_CREATE_DTOR, 1, - [kmem_cache_create has dtor argument]) + hlist_add_after(NULL, NULL); ],[ - AC_MSG_RESULT(NO) -]) + AC_DEFINE(HAVE_HLIST_ADD_AFTER, 1, + [hlist_add_after is available]) ]) +]) # LIBCFS_HLIST_ADD_AFTER -# 2.6.24 -AC_DEFUN([LIBCFS_NETLINK_CBMUTEX], -[AC_MSG_CHECKING([for mutex in netlink_kernel_create]) -LB_LINUX_TRY_COMPILE([ - #include +# +# Kernel version 3.17 introduced struct timespec64 +# +AC_DEFUN([LIBCFS_TIMESPEC64],[ +LB_CHECK_COMPILE([does 'struct timespec64' exist], +timespec64, [ + #include ],[ - struct mutex *lock = NULL; + struct timespec64 ts; - netlink_kernel_create(0, 0, NULL, lock, NULL); + ts.tv_sec = 0; + ts.tv_nsec = 0; ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_NETLINK_CBMUTEX, 1, - [netlink_kernel_create want mutex for callback]) -],[ - AC_MSG_RESULT(NO) -]) + AC_DEFINE(HAVE_TIMESPEC64, 1, + ['struct timespec64' is available]) ]) +]) # LIBCFS_TIMESPEC64 -# 2.6.24 request not use real numbers for ctl_name -AC_DEFUN([LIBCFS_SYSCTL_UNNUMBERED], -[AC_MSG_CHECKING([for CTL_UNNUMBERED]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - #ifndef CTL_UNNUMBERED - #error CTL_UNNUMBERED not exist in kernel - #endif +# +# Kernel version 3.17 introduced ktime_get_real_ts64 +# +AC_DEFUN([LIBCFS_KTIME_GET_REAL_TS64],[ +LB_CHECK_COMPILE([does function 'ktime_get_real_ts64' exist], +ktime_get_real_ts64, [ + #include ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_SYSCTL_UNNUMBERED, 1, - [sysctl has CTL_UNNUMBERED]) + struct timespec64 *ts = NULL; + + ktime_get_real_ts64(ts); ],[ - AC_MSG_RESULT(NO) -]) + AC_DEFINE(HAVE_KTIME_GET_REAL_TS64, 1, + ['ktime_get_real_ts64' is available]) ]) +]) # LIBCFS_KTIME_GET_REAL_TS64 -# 2.6.24 lost scatterlist->page -AC_DEFUN([LIBCFS_SCATTERLIST_SETPAGE], -[AC_MSG_CHECKING([for exist sg_set_page]) -LB_LINUX_TRY_COMPILE([ - #include - #include -],[ - sg_set_page(NULL,NULL,0,0); +# +# Kernel version 3.17 introduced ktime_get_real_seconds +# +AC_DEFUN([LIBCFS_KTIME_GET_REAL_SECONDS],[ +LB_CHECK_COMPILE([does function 'ktime_get_real_seconds' exist], +ktime_get_real_seconds, [ + #include + #include ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_SCATTERLIST_SETPAGE, 1, - [struct scatterlist has page member]) + time64_t now; + + now = ktime_get_real_seconds(); ],[ - AC_MSG_RESULT(NO) + AC_DEFINE(HAVE_KTIME_GET_REAL_SECONDS, 1, + ['ktime_get_real_seconds' is available]) ]) +]) # LIBCFS_KTIME_GET_REAL_SECONDS + +# +# Kernel version 3.17 created ktime_get_ns wrapper +# +AC_DEFUN([LIBCFS_KTIME_GET_NS],[ +LB_CHECK_COMPILE([does function 'ktime_get_ns' exist], +ktime_get_ns, [ + #include + #include +],[ + u64 nanoseconds; + + nanoseconds = ktime_get_ns(); +],[],[ + AC_DEFINE(NEED_KTIME_GET_NS, 1, + ['ktime_get_ns' is not available]) ]) +]) # LIBCFS_KTIME_GET_NS -# from 2.6.24 please use sg_init_table -AC_DEFUN([LIBCFS_SCATTERLIST_INITTABLE], -[AC_MSG_CHECKING([if sg_init_table is defined]) -LB_LINUX_TRY_COMPILE([ - #include +# +# Kernel version 3.17 created ktime_get_real_ns wrapper +# +AC_DEFUN([LIBCFS_KTIME_GET_REAL_NS],[ +LB_CHECK_COMPILE([does function 'ktime_get_real_ns' exist], +ktime_get_real_ns, [ + #include + #include ],[ - sg_init_table(NULL,0); + u64 nanoseconds; + + nanoseconds = ktime_get_real_ns(); +],[],[ + AC_DEFINE(NEED_KTIME_GET_REAL_NS, 1, + ['ktime_get_real_ns' is not available]) +]) +]) # LIBCFS_KTIME_GET_REAL_NS + +# +# Kernel version 3.17 introduced ktime_to_timespec64 +# +AC_DEFUN([LIBCFS_KTIME_TO_TIMESPEC64],[ +LB_CHECK_COMPILE([does function 'ktime_to_timespec64' exist], +ktime_to_timespec64, [ + #include + #include ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_SCATTERLIST_INITTABLE, 1, - [sg_init_table is defined]) + ktime_t now = ktime_set(0, 0); + struct timespec64 ts; + + ts = ktime_to_timespec64(now); ],[ - AC_MSG_RESULT(NO) -]) + AC_DEFINE(HAVE_KTIME_TO_TIMESPEC64, 1, + ['ktime_to_timespec64' is available]) ]) +]) # LIBCFS_KTIME_TO_TIMESPEC64 -# 2.6.24 -AC_DEFUN([LIBCFS_NETWORK_NAMESPACE], -[AC_MSG_CHECKING([for network stack has namespaces]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - struct net *net = &init_net; +# +# Kernel version 3.17 introduced timespec64_sub +# +AC_DEFUN([LIBCFS_TIMESPEC64_SUB],[ +LB_CHECK_COMPILE([does function 'timespec64_sub' exist], +timespec64_sub, [ + #include ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_INIT_NET, 1, - [kernel is support network namespaces ]) + struct timespec64 later = { }, earlier = { }, diff; + + diff = timespec64_sub(later, earlier); ],[ - AC_MSG_RESULT(NO) -]) + AC_DEFINE(HAVE_TIMESPEC64_SUB, 1, + ['timespec64_sub' is available]) ]) +]) # LIBCFS_TIMESPEC64_SUB +# +# Kernel version 3.17 introduced timespec64_to_ktime +# +AC_DEFUN([LIBCFS_TIMESPEC64_TO_KTIME],[ +LB_CHECK_COMPILE([does function 'timespec64_to_ktime' exist], +timespec64_to_ktime, [ + #include +],[ + struct timespec64 ts; + ktime_t now; -# 2.6.24 -AC_DEFUN([LIBCFS_NETLINK_NETNS], -[AC_MSG_CHECKING([for netlink support net ns]) -LB_LINUX_TRY_COMPILE([ - #include + now = timespec64_to_ktime(ts); ],[ - struct net *net = NULL; - struct mutex *lock = NULL; + AC_DEFINE(HAVE_TIMESPEC64_TO_KTIME, 1, + ['timespec64_to_ktime' is available]) +]) +]) # LIBCFS_TIMESPEC64_TO_KTIME - netlink_kernel_create(net, 0, 0, NULL, - lock, - NULL); +# +# Kernel version 3.19 introduced ktime_get_seconds +# +AC_DEFUN([LIBCFS_KTIME_GET_SECONDS],[ +LB_CHECK_COMPILE([does function 'ktime_get_seconds' exist], +ktime_get_seconds, [ + #include ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_NETLINK_NS, 1, - [netlink is support network namespace]) -# XXX -# for now - if kernel have netlink ns - he uses cbmutex - AC_DEFINE(HAVE_NETLINK_CBMUTEX, 1, - [netlink_kernel_create want mutex for callback]) + time64_t now; + now = ktime_get_seconds(); ],[ - AC_MSG_RESULT(NO) + AC_DEFINE(HAVE_KTIME_GET_SECONDS, 1, + ['ktime_get_seconds' is available]) ]) +]) # LIBCFS_KTIME_GET_SECONDS + +# +# Kernel version 3.19 commit 5aaba36318e5995e8c95d077a46d9a4d00fcc1cd +# This patch creates a new helper function cpumap_print_to_pagebuf in +# cpumask.h using newly added bitmap_print_to_pagebuf and consolidates +# most of those sysfs functions using the new helper function. +# +AC_DEFUN([LIBCFS_HAVE_CPUMASK_PRINT_TO_PAGEBUF],[ +LB_CHECK_COMPILE([does function 'cpumap_print_to_pagebuf' exist], +cpumap_print_to_pagebuf, [ + #include +],[ + int n; + char *buf = NULL; + const struct cpumask *mask = NULL; + n = cpumap_print_to_pagebuf(true, buf, mask); +],[ + AC_DEFINE(HAVE_CPUMASK_PRINT_TO_PAGEBUF, 1, + [cpumap_print_to_pagebuf is available]) ]) +]) # LIBCFS_HAVE_CPUMASK_PRINT_TO_PAGEBUF -# ~2.6.24 -AC_DEFUN([LIBCFS_NL_BROADCAST_GFP], -[AC_MSG_CHECKING([for netlink_broadcast is want to have gfp parameter]) -LB_LINUX_TRY_COMPILE([ - #include +# +# Kernel version 4.0 commit 41fbf3b39d5eca01527338b4d0ee15ee1ae1023c +# introduced the helper function ktime_ms_delta. +# +AC_DEFUN([LIBCFS_KTIME_MS_DELTA],[ +LB_CHECK_COMPILE([does function 'ktime_ms_delta' exist], +ktime_ms_delta, [ + #include ],[ - gfp_t gfp = GFP_KERNEL; + ktime_t start = ktime_set(0, 0); + ktime_t end = start; - netlink_broadcast(NULL, NULL, 0, 0, gfp); + ktime_ms_delta(start, end); ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_NL_BROADCAST_GFP, 1, - [netlink brouacast is want to have gfp paramter]) + AC_DEFINE(HAVE_KTIME_MS_DELTA, 1, + ['ktime_ms_delta' is available]) +]) +]) # LIBCFS_KTIME_MS_DELTA + +# +# Kernel version 4.1 commit b51d23e4e9fea6f264d39535c2a62d1f51e7ccc3 +# create per module locks which added kernel_param_[un]lock(). Older +# kernels you have to use __kernel_param_[un]lock(). In that case its +# a global lock for all modules but that is okay since its a rare event. +# +AC_DEFUN([LIBCFS_KERNEL_PARAM_LOCK],[ +LB_CHECK_COMPILE([does function 'kernel_param_[un]lock' exist], +kernel_param_lock, [ + #include +],[ + kernel_param_lock(NULL); + kernel_param_unlock(NULL); ],[ - AC_MSG_RESULT(NO) + AC_DEFINE(HAVE_KERNEL_PARAM_LOCK, 1, + ['kernel_param_[un]lock' is available]) ]) +]) # LIBCFS_KERNEL_PARAM_LOCK + +# +# Kernel version 4.2 changed topology_thread_cpumask +# to topology_sibling_cpumask +# +AC_DEFUN([LIBCFS_HAVE_TOPOLOGY_SIBLING_CPUMASK],[ +LB_CHECK_COMPILE([does function 'topology_sibling_cpumask' exist], +topology_sibling_cpumask, [ + #include +],[ + const struct cpumask *mask; + + mask = topology_sibling_cpumask(0); +],[ + AC_DEFINE(HAVE_TOPOLOGY_SIBLING_CPUMASK, 1, + [topology_sibling_cpumask is available]) ]) +]) # LIBCFS_HAVE_TOPOLOGY_SIBLING_CPUMASK # -# LIBCFS_FUNC_DUMP_TRACE +# Kernel version 4.2 commit df6b35f409af0a8ff1ef62f552b8402f3fef8665 +# header file i387.h was renamed to fpu/api.h # -# 2.6.23 exports dump_trace() so we can dump_stack() on any task -# 2.6.24 has stacktrace_ops.address with "reliable" parameter +AC_DEFUN([LIBCFS_FPU_API], [ +LB_CHECK_LINUX_HEADER([asm/fpu/api.h], [ + AC_DEFINE(HAVE_FPU_API_HEADER, 1, + [fpu/api.h is present])]) +]) # LIBCFS_FPU_API + # -AC_DEFUN([LIBCFS_FUNC_DUMP_TRACE], -[LB_CHECK_SYMBOL_EXPORT([dump_trace], -[kernel/ksyms.c arch/${LINUX_ARCH%_64}/kernel/traps_64.c],[ - tmp_flags="$EXTRA_KCFLAGS" - EXTRA_KCFLAGS="-Werror" - AC_MSG_CHECKING([whether we can really use dump_trace]) - LB_LINUX_TRY_COMPILE([ - struct task_struct; - struct pt_regs; - #include - ],[ - ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_DUMP_TRACE, 1, [dump_trace is exported]) - ],[ - AC_MSG_RESULT(no) - ],[ - ]) - AC_MSG_CHECKING([whether print_trace_address has reliable argument]) - LB_LINUX_TRY_COMPILE([ - struct task_struct; - struct pt_regs; - void print_addr(void *data, unsigned long addr, int reliable); - #include - ],[ - struct stacktrace_ops ops; - - ops.address = print_addr; - ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_TRACE_ADDRESS_RELIABLE, 1, - [print_trace_address has reliable argument]) - ],[ - AC_MSG_RESULT(no) - ],[ - ]) -EXTRA_KCFLAGS="$tmp_flags" +# Kernel version 4.4 commit ef951599074ba4fad2d0efa0a977129b41e6d203 +# introduced kstrtobool and kstrtobool_from_user. +# +AC_DEFUN([LIBCFS_KSTRTOBOOL_FROM_USER], [ +LB_CHECK_COMPILE([if Linux kernel has 'kstrtobool_from_user'], +kstrtobool_from_user, [ + #include +],[ + bool result; + return kstrtobool_from_user(NULL, 0, &result); +],[ + AC_DEFINE(HAVE_KSTRTOBOOL_FROM_USER, 1, + [kernel has kstrtobool_from_user]) ]) +]) # LIBCFS_KSTRTOBOOL_FROM_USER + +# +# Kernel version 4.5-rc1 commit d12481bc58fba89427565f8592e88446ec084a24 +# added crypto hash helpers +# +AC_DEFUN([LIBCFS_CRYPTO_HASH_HELPERS], [ +LB_CHECK_COMPILE([does crypto hash helper functions exist], +crypto_hash_helpers, [ + #include +],[ + crypto_ahash_alg_name(NULL); + crypto_ahash_driver_name(NULL); +],[ + AC_DEFINE(HAVE_CRYPTO_HASH_HELPERS, 1, + [crypto hash helper functions are available]) ]) +]) # LIBCFS_CRYPTO_HASH_HELPERS +# +# Kernerl version 4.5-rc3 commit 2fe829aca9d7bed5fd6b49c6a1452e5e486b6cc3dd +# made kset_find_obj() exportable to modules +# +AC_DEFUN([LIBCFS_EXPORT_KSET_FIND_OBJ], [ +LB_CHECK_EXPORT([kset_find_obj], [lib/kobject.c], + [AC_DEFINE(HAVE_KSET_FIND_OBJ, 1, + [kset_find_obj is exported by the kernel])]) +]) # LIBCFS_EXPORT_KSET_FIND_OBJ -# 2.6.26 use int instead of atomic for sem.count -AC_DEFUN([LIBCFS_SEM_COUNT], -[AC_MSG_CHECKING([atomic sem.count]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - struct semaphore s; - - atomic_read(&s.count); +# +# LIBCFS_STACKTRACE_OPS_ADDRESS_RETURN_INT +# +# linux 4.6 kernel changed stacktrace_ops address to return an int +# +AC_DEFUN([LIBCFS_STACKTRACE_OPS_ADDRESS_RETURN_INT], [ +LB_CHECK_COMPILE([if 'struct stacktrace_ops' address function returns an int], +stacktrace_ops_address_return_int, [ + #include ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_SEM_COUNT_ATOMIC, 1, - [semaphore counter is atomic]) + int rc; + + rc = ((struct stacktrace_ops *)0)->address(NULL, 0, 0); ],[ - AC_MSG_RESULT(NO) -]) + AC_DEFINE(STACKTRACE_OPS_ADDRESS_RETURN_INT, 1, + ['struct stacktrace_ops' address function returns an int]) ]) +]) # LIBCFS_STACKTRACE_OPS_ADDRESS_RETURN_INT -# 2.6.27 have second argument to sock_map_fd -AC_DEFUN([LIBCFS_SOCK_MAP_FD_2ARG], -[AC_MSG_CHECKING([sock_map_fd have second argument]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - sock_map_fd(NULL, 0); +# +# Kernel version 4.6 removed both struct task_struct and struct mm_struct +# arguments to get_user_pages +# +AC_DEFUN([LIBCFS_GET_USER_PAGES_6ARG], [ +LB_CHECK_COMPILE([if 'get_user_pages()' takes 6 arguments], +get_user_pages_6arg, [ + #include ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_SOCK_MAP_FD_2ARG, 1, - [sock_map_fd have second argument]) + int rc; + + rc = get_user_pages(0, 0, 0, 0, NULL, NULL); ],[ - AC_MSG_RESULT(NO) -]) + AC_DEFINE(HAVE_GET_USER_PAGES_6ARG, 1, + [get_user_pages takes 6 arguments]) ]) +]) # LIBCFS_GET_USER_PAGES_6ARG -# LIBCFS_CRED_WRAPPERS # -# wrappers for task's credentials are in sles11 +# LIBCFS_STACKTRACE_OPS # -AC_DEFUN([LIBCFS_CRED_WRAPPERS], -[AC_MSG_CHECKING([if kernel has wrappers for task's credentials]) -LB_LINUX_TRY_COMPILE([ - #include +# Kernel version 4.8 commit c8fe4609827aedc9c4b45de80e7cdc8ccfa8541b +# removed both struct stacktrace_ops and dump_trace() function +# +AC_DEFUN([LIBCFS_STACKTRACE_OPS], [ +LB_CHECK_COMPILE([if 'struct stacktrace_ops' exists], +stacktrace_ops, [ + struct task_struct; + struct pt_regs; + #include +],[ + struct stacktrace_ops ops; + ops.stack = NULL; ],[ - uid_t uid; + AC_DEFINE(HAVE_STACKTRACE_OPS, 1, + [struct stacktrace_ops exists]) +]) +]) # LIBCFS_STACKTRACE_OPS - uid = current_uid(); +# +# Kernel version 4.9 commit 768ae309a96103ed02eb1e111e838c87854d8b51 +# mm: replace get_user_pages() write/force parameters with gup_flags +# +AC_DEFUN([LIBCFS_GET_USER_PAGES_GUP_FLAGS], [ +LB_CHECK_COMPILE([if 'get_user_pages()' takes gup_flags in arguments], +get_user_pages_gup_flags, [ + #include ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_CRED_WRAPPERS, 1, [task's cred wrappers found]) + int rc; + rc = get_user_pages(0, 0, FOLL_WRITE, NULL, NULL); ],[ - AC_MSG_RESULT([no]) + AC_DEFINE(HAVE_GET_USER_PAGES_GUP_FLAGS, 1, + [get_user_pages takes gup_flags in arguments]) ]) +]) # LIBCFS_GET_USER_PAGES_GUP_FLAGS + +# +# Kernel version 4.10 commit 7b737965b33188bd3dbb44e938535c4006d97fbb +# libcfs: Convert to hotplug state machine +# +AC_DEFUN([LIBCFS_HOTPLUG_STATE_MACHINE], [ +LB_CHECK_COMPILE([if libcfs supports CPU hotplug state machine], +cpu_hotplug_state_machine, [ + #include +],[ + cpuhp_remove_state(CPUHP_LUSTRE_CFS_DEAD); +],[ + AC_DEFINE(HAVE_HOTPLUG_STATE_MACHINE, 1, + [hotplug state machine is supported]) ]) +]) # LIBCFS_HOTPLUG_STATE_MACHINE # -# LN_STRUCT_CRED_IN_TASK +# LIBCFS_SCHED_HEADERS # -# struct cred was introduced in 2.6.29 to streamline credentials in task struct +# 4.11 has broken up sched.h into more headers. # -AC_DEFUN([LIBCFS_STRUCT_CRED_IN_TASK], -[AC_MSG_CHECKING([if kernel has struct cred]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - struct task_struct *tsk = NULL; - tsk->real_cred = NULL; +AC_DEFUN([LIBCFS_SCHED_HEADERS], [ +LB_CHECK_LINUX_HEADER([linux/sched/signal.h], [ + AC_DEFINE(HAVE_SCHED_HEADERS, 1, + [linux/sched header directory exist])]) +]) # LIBCFS_SCHED_HEADERS + +# +# LIBCFS_WAIT_QUEUE_ENTRY +# +# Kernel version 4.13 ac6424b981bce1c4bc55675c6ce11bfe1bbfa64f +# Rename wait_queue_t => wait_queue_entry_t +# +AC_DEFUN([LIBCFS_WAIT_QUEUE_ENTRY], [ +LB_CHECK_COMPILE([if 'wait_queue_entry_t' exists], +wait_queue_entry, [ + #include ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_STRUCT_CRED, 1, [struct cred found]) + wait_queue_entry_t e; + + e.flags = 0; ],[ - AC_MSG_RESULT([no]) -]) + AC_DEFINE(HAVE_WAIT_QUEUE_ENTRY, 1, + ['wait_queue_entry_t' is available]) ]) +]) # LIBCFS_WAIT_QUEUE_ENTRY # -# LIBCFS_FUNC_UNSHARE_FS_STRUCT +# LIBCFS_NEW_KERNEL_WRITE # -# unshare_fs_struct was introduced in 2.6.30 to prevent others to directly -# mess with copy_fs_struct +# Kernel version 4.14 e13ec939e96b13e664bb6cee361cc976a0ee621a +# changed kernel_write prototype to make is plug compatible +# with the unexported vfs_write() # -AC_DEFUN([LIBCFS_FUNC_UNSHARE_FS_STRUCT], -[AC_MSG_CHECKING([if kernel defines unshare_fs_struct()]) +AC_DEFUN([LIBCFS_NEW_KERNEL_WRITE], [ tmp_flags="$EXTRA_KCFLAGS" EXTRA_KCFLAGS="-Werror" -LB_LINUX_TRY_COMPILE([ - #include - #include -],[ - unshare_fs_struct(); +LB_CHECK_COMPILE([if 'kernel_write' matches other read/write helpers], +kernel_write_match, [ + #include ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_UNSHARE_FS_STRUCT, 1, [unshare_fs_struct found]) + const void *buf = NULL; + loff_t pos = 0; + return kernel_write(NULL, buf, 0, &pos); ],[ - AC_MSG_RESULT([no]) + AC_DEFINE(HAVE_NEW_KERNEL_WRITE, 1, + ['kernel_write' aligns with read/write helpers]) ]) EXTRA_KCFLAGS="$tmp_flags" -]) +]) # LIBCFS_NEW_KERNEL_WRITE # -# LIBCFS_HAVE_IS_COMPAT_TASK +# LIBCFS_TIMER_SETUP # -# Added in 2.6.17, it wasn't until 2.6.29 that all -# Linux architectures have is_compat_task() +# Kernel version 4.15 commit e99e88a9d2b067465adaa9c111ada99a041bef9a +# setup_timer() was replaced by timer_setup(), where the callback +# argument is the structure already holding the struct timer_list. # -AC_DEFUN([LIBCFS_HAVE_IS_COMPAT_TASK], -[AC_MSG_CHECKING([if is_compat_task() is declared]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - int i = is_compat_task(); +AC_DEFUN([LIBCFS_TIMER_SETUP], [ +LB_CHECK_COMPILE([if setup_timer has been replaced with timer_setup], +timer_setup, [ + #include ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_IS_COMPAT_TASK, 1, [is_compat_task() is available]) + timer_setup(NULL, NULL, 0); ],[ - AC_MSG_RESULT([no]) -]) + AC_DEFINE(HAVE_TIMER_SETUP, 1, + [timer_setup has replaced setup_timer]) ]) +]) # LIBCFS_TIMER_SETUP # # LIBCFS_PROG_LINUX # -# LNet linux kernel checks +# LibCFS linux kernel checks # -AC_DEFUN([LIBCFS_PROG_LINUX], -[ -LIBCFS_FUNC_CPU_ONLINE -LIBCFS_TYPE_GFP_T -LIBCFS_TYPE_CPUMASK_T +AC_DEFUN([LIBCFS_PROG_LINUX], [ +AC_MSG_NOTICE([LibCFS kernel checks +==============================================================================]) LIBCFS_CONFIG_PANIC_DUMPLOG -LIBCFS_STRUCT_PAGE_LIST -LIBCFS_STRUCT_SIGHAND -LIBCFS_FUNC_SHOW_TASK -LIBCFS_U64_LONG_LONG -LIBCFS_TASK_RCU -# 2.6.18 -LIBCFS_TASKLIST_LOCK -LIBCFS_HAVE_IS_COMPAT_TASK -# 2.6.19 -LIBCFS_NETLINK -LIBCFS_NLMSG_MULTICAST -LIBCFS_KMEM_CACHE_DESTROY_INT -LIBCFS_ATOMIC_PANIC_NOTIFIER -# 2.6.20 -LIBCFS_3ARGS_INIT_WORK -# 2.6.21 -LIBCFS_2ARGS_REGISTER_SYSCTL -LIBCFS_KMEM_CACHE -# 2.6.23 -LIBCFS_KMEM_CACHE_CREATE_DTOR -LIBCFS_NETLINK_CBMUTEX -# 2.6.24 -LIBCFS_SYSCTL_UNNUMBERED -LIBCFS_SCATTERLIST_SETPAGE -LIBCFS_SCATTERLIST_INITTABLE -LIBCFS_NL_BROADCAST_GFP -LIBCFS_NETWORK_NAMESPACE -LIBCFS_NETLINK_NETNS -LIBCFS_FUNC_DUMP_TRACE -# 2.6.26 -LIBCFS_SEM_COUNT -# 2.6.27 -LIBCFS_CRED_WRAPPERS -# 2.6.29 -LIBCFS_STRUCT_CRED_IN_TASK -# 2.6.30 -LIBCFS_FUNC_UNSHARE_FS_STRUCT -LIBCFS_SOCK_MAP_FD_2ARG -]) - -# -# LIBCFS_PROG_DARWIN -# -# Darwin checks -# -AC_DEFUN([LIBCFS_PROG_DARWIN], -[LB_DARWIN_CHECK_FUNCS([get_preemption_level]) -]) +# 2.6.32 +LIBCFS_STACKTRACE_OPS_HAVE_WALK_STACK +LC_SHRINKER_WANT_SHRINK_PTR +# 2.6.33 +LIBCFS_SYSCTL_CTLNAME +# 2.6.36 +LIBCFS_MODULE_LOCKING +# 2.6.38 +LIBCFS_KSTRTOUL +# 2.6.39 +LIBCFS_DUMP_TRACE_ADDRESS +# 2.6.40 fc15 +LC_SHRINK_CONTROL +# 3.0 +LIBCFS_STACKTRACE_WARNING +LIBCFS_REINIT_COMPLETION +# 3.5 +LIBCFS_PROCESS_NAMESPACE +LIBCFS_I_UID_READ +# 3.8 +LIBCFS_HAVE_CRC32 +LIBCFS_ENABLE_CRC32_ACCEL +# 3.10 +LIBCFS_ENABLE_CRC32C_ACCEL +# 3.11 +LIBCFS_KTIME_GET_TS64 +# 3.12 +LIBCFS_KERNEL_PARAM_OPS +LIBCFS_KTIME_ADD +LIBCFS_KTIME_AFTER +LIBCFS_KTIME_BEFORE +LIBCFS_KTIME_COMPARE +LIBCFS_SHRINKER_COUNT +# 3.17 +LIBCFS_HLIST_ADD_AFTER +LIBCFS_TIMESPEC64 +LIBCFS_KTIME_GET_NS +LIBCFS_KTIME_GET_REAL_TS64 +LIBCFS_KTIME_GET_REAL_SECONDS +LIBCFS_KTIME_GET_REAL_NS +LIBCFS_KTIME_TO_TIMESPEC64 +LIBCFS_TIMESPEC64_SUB +LIBCFS_TIMESPEC64_TO_KTIME +# 3.19 +LIBCFS_KTIME_GET_SECONDS +LIBCFS_HAVE_CPUMASK_PRINT_TO_PAGEBUF +# 4.0 +LIBCFS_KTIME_MS_DELTA +# 4.1 +LIBCFS_KERNEL_PARAM_LOCK +# 4.2 +LIBCFS_HAVE_TOPOLOGY_SIBLING_CPUMASK +LIBCFS_FPU_API +# 4.4 +LIBCFS_KSTRTOBOOL_FROM_USER +# 4.5 +LIBCFS_CRYPTO_HASH_HELPERS +LIBCFS_EXPORT_KSET_FIND_OBJ +# 4.6 +LIBCFS_STACKTRACE_OPS_ADDRESS_RETURN_INT +LIBCFS_GET_USER_PAGES_6ARG +# 4.8 +LIBCFS_STACKTRACE_OPS +# 4.9 +LIBCFS_GET_USER_PAGES_GUP_FLAGS +# 4.10 +LIBCFS_HOTPLUG_STATE_MACHINE +# 4.11 +LIBCFS_SCHED_HEADERS +# 4.13 +LIBCFS_WAIT_QUEUE_ENTRY +# 4.14 +LIBCFS_NEW_KERNEL_WRITE +# 4.15 +LIBCFS_TIMER_SETUP +]) # LIBCFS_PROG_LINUX # # LIBCFS_PATH_DEFAULTS # # default paths for installed files # -AC_DEFUN([LIBCFS_PATH_DEFAULTS], -[ -]) +AC_DEFUN([LIBCFS_PATH_DEFAULTS], [ +]) # LIBCFS_PATH_DEFAULTS # # LIBCFS_CONFIGURE # # other configure checks # -AC_DEFUN([LIBCFS_CONFIGURE], -[# lnet/utils/portals.c -AC_CHECK_HEADERS([asm/types.h endian.h sys/ioctl.h]) - -# lnet/utils/debug.c -AC_CHECK_HEADERS([linux/version.h]) - -AC_CHECK_TYPE([spinlock_t], - [AC_DEFINE(HAVE_SPINLOCK_T, 1, [spinlock_t is defined])], - [], - [#include ]) - -# lnet/utils/wirecheck.c -AC_CHECK_FUNCS([strnlen]) - -AC_CHECK_TYPE([umode_t], - [AC_DEFINE(HAVE_UMODE_T, 1, [umode_t is defined])], - [], - [#include ]) - -AC_CHECK_TYPE([__s8], - [AC_DEFINE(HAVE___S8, 1, [__s8 is defined])], - [], - [#include ]) - -AC_CHECK_TYPE([__u8], - [AC_DEFINE(HAVE___U8, 1, [__u8 is defined])], - [], - [#include ]) - -AC_CHECK_TYPE([__s16], - [AC_DEFINE(HAVE___S16, 1, [__s16 is defined])], - [], - [#include ]) - -AC_CHECK_TYPE([__u16], - [AC_DEFINE(HAVE___U16, 1, [__u16 is defined])], - [], - [#include ]) - -AC_CHECK_TYPE([__s32], - [AC_DEFINE(HAVE___S32, 1, [__s32 is defined])], - [], - [#include ]) - -AC_CHECK_TYPE([__u32], - [AC_DEFINE(HAVE___U32, 1, [__u32 is defined])], - [], - [#include ]) - -AC_CHECK_TYPE([__u64], - [AC_DEFINE(HAVE___U64, 1, [__u64 is defined])], - [], - [#include ]) - -AC_CHECK_TYPE([__s64], - [AC_DEFINE(HAVE___S64, 1, [__s64 is defined])], - [], - [#include ]) - -# -------- Check for required packages -------------- +AC_DEFUN([LIBCFS_CONFIGURE], [ +AC_MSG_NOTICE([LibCFS core checks +==============================================================================]) +# libcfs/libcfs/util/nidstrings.c +AC_CHECK_HEADERS([netdb.h asm/types.h endian.h]) +AC_CHECK_FUNCS([gethostbyname]) -AC_MSG_CHECKING([if efence debugging support is requested]) -AC_ARG_ENABLE(efence, - AC_HELP_STRING([--enable-efence], - [use efence library]), - [],[enable_efence='no']) -AC_MSG_RESULT([$enable_efence]) -if test "$enable_efence" = "yes" ; then - LIBEFENCE="-lefence" - AC_DEFINE(HAVE_LIBEFENCE, 1, [libefence support is requested]) -else - LIBEFENCE="" -fi -AC_SUBST(LIBEFENCE) +# -------- Check for required packages -------------- +AC_MSG_NOTICE([LibCFS required packages checks +==============================================================================]) + +AC_MSG_CHECKING([whether to enable readline support]) +AC_ARG_ENABLE(readline, + AC_HELP_STRING([--disable-readline], + [disable readline support]), + [], [enable_readline="yes"]) +AC_MSG_RESULT([$enable_readline]) + +LIBREADLINE="" +AS_IF([test "x$enable_readline" = xyes], [ + AC_CHECK_LIB([readline], [readline], [ + LIBREADLINE="-lreadline" + AC_DEFINE(HAVE_LIBREADLINE, 1, + [readline library is available]) + ]) +]) +AC_SUBST(LIBREADLINE) -# -------- check for -lpthread support ---- AC_MSG_CHECKING([whether to use libpthread for libcfs library]) AC_ARG_ENABLE([libpthread], - AC_HELP_STRING([--disable-libpthread], - [disable libpthread]), - [],[enable_libpthread=yes]) -if test "$enable_libpthread" = "yes" ; then - AC_CHECK_LIB([pthread], [pthread_create], - [ENABLE_LIBPTHREAD="yes"], - [ENABLE_LIBPTHREAD="no"]) - if test "$ENABLE_LIBPTHREAD" = "yes" ; then - AC_MSG_RESULT([$ENABLE_LIBPTHREAD]) + AC_HELP_STRING([--disable-libpthread], + [disable libpthread]), + [], [enable_libpthread="yes"]) +AC_MSG_RESULT([$enable_libpthread]) + +PTHREAD_LIBS="" +AS_IF([test "x$enable_libpthread" = xyes], [ + AC_CHECK_LIB([pthread], [pthread_create], [ PTHREAD_LIBS="-lpthread" - AC_DEFINE([HAVE_LIBPTHREAD], 1, [use libpthread]) - else - PTHREAD_LIBS="" - AC_MSG_RESULT([no libpthread is found]) - fi - AC_SUBST(PTHREAD_LIBS) -else - AC_MSG_RESULT([no (disabled explicitly)]) - ENABLE_LIBPTHREAD="no" -fi -AC_SUBST(ENABLE_LIBPTHREAD) - - + AC_DEFINE([HAVE_LIBPTHREAD], 1, + [use libpthread for libcfs library]) + ]) +], [ + AC_MSG_WARN([Using libpthread for libcfs library is disabled explicitly]) ]) +AC_SUBST(PTHREAD_LIBS) +]) # LIBCFS_CONFIGURE # # LIBCFS_CONDITIONALS # -# AM_CONDITOINAL defines for lnet -# -AC_DEFUN([LIBCFS_CONDITIONALS], -[ -]) +AC_DEFUN([LIBCFS_CONDITIONALS], [ +AM_CONDITIONAL(HAVE_CRC32, [test "x$have_crc32" = xyes]) +AM_CONDITIONAL(NEED_PCLMULQDQ_CRC32, [test "x$have_crc32" = xyes -a "x$enable_crc32_crypto" = xyes]) +AM_CONDITIONAL(NEED_PCLMULQDQ_CRC32C, [test "x$enable_crc32c_crypto" = xyes]) +]) # LIBCFS_CONDITIONALS # # LIBCFS_CONFIG_FILES # # files that should be generated with AC_OUTPUT # -AC_DEFUN([LIBCFS_CONFIG_FILES], -[AC_CONFIG_FILES([ -libcfs/Kernelenv +AC_DEFUN([LIBCFS_CONFIG_FILES], [ +AC_CONFIG_FILES([ libcfs/Makefile libcfs/autoMakefile libcfs/autoconf/Makefile libcfs/include/Makefile libcfs/include/libcfs/Makefile libcfs/include/libcfs/linux/Makefile -libcfs/include/libcfs/posix/Makefile libcfs/include/libcfs/util/Makefile libcfs/libcfs/Makefile libcfs/libcfs/autoMakefile libcfs/libcfs/linux/Makefile -libcfs/libcfs/posix/Makefile libcfs/libcfs/util/Makefile -libcfs/include/libcfs/darwin/Makefile -libcfs/libcfs/darwin/Makefile -]) ]) +]) # LIBCFS_CONFIG_FILES