X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=libcfs%2Fautoconf%2Flustre-libcfs.m4;h=4774cac789354f6a84f702cc9edf7cef4d106826;hp=8b088baf86998f625c7085e8f030dc129b3ca5dd;hb=e37335b2d8c2dc74badea8978ab3f46a63621265;hpb=9ed879b12c07d1f4de2fe55f35318ed8cdd8995c diff --git a/libcfs/autoconf/lustre-libcfs.m4 b/libcfs/autoconf/lustre-libcfs.m4 index 8b088ba..4774cac 100644 --- a/libcfs/autoconf/lustre-libcfs.m4 +++ b/libcfs/autoconf/lustre-libcfs.m4 @@ -1,9 +1,9 @@ # -# 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], @@ -30,7 +30,7 @@ AC_ARG_ENABLE([libcfs_assert], AC_MSG_RESULT([$enable_libcfs_assert]) AS_IF([test x$enable_libcfs_assert = xyes], [AC_DEFINE(LIBCFS_DEBUG, 1, [enable libcfs LASSERT, LASSERTF])]) -]) # LN_CONFIG_CDEBUG +]) # LIBCFS_CONFIG_CDEBUG # # LIBCFS_CONFIG_PANIC_DUMPLOG @@ -85,6 +85,22 @@ stacktrace_ops_warning, [ ]) # 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 + +# # LC_SHRINKER_WANT_SHRINK_PTR # # RHEL6/2.6.32 want to have pointer to shrinker self pointer in handler function @@ -121,40 +137,40 @@ ctl_table_ctl_name, [ ]) # LIBCFS_SYSCTL_CTLNAME # -# LIBCFS_ADD_WAIT_QUEUE_EXCLUSIVE +# LIBCFS_MODULE_LOCKING # -# 2.6.34 adds __add_wait_queue_exclusive +# 2.6.36 introduced locking to module params. RHEL6 lacks this support # -AC_DEFUN([LIBCFS_ADD_WAIT_QUEUE_EXCLUSIVE], [ -LB_CHECK_COMPILE([if '__add_wait_queue_exclusive' exists], -__add_wait_queue_exclusive, [ - #include +AC_DEFUN([LIBCFS_MODULE_LOCKING],[ +LB_CHECK_COMPILE([does the kernel support module param locking], +module_param_locking, [ + #include ],[ - wait_queue_head_t queue; - wait_queue_t wait; - __add_wait_queue_exclusive(&queue, &wait); + __kernel_param_lock(NULL); + __kernel_param_unlock(NULL); ],[ - AC_DEFINE(HAVE___ADD_WAIT_QUEUE_EXCLUSIVE, 1, - [__add_wait_queue_exclusive exists]) + AC_DEFINE(HAVE_MODULE_PARAM_LOCKING, 1, + [locking module param is supported]) ]) -]) # LIBCFS_ADD_WAIT_QUEUE_EXCLUSIVE +]) # LIBCFS_MODULE_LOCKING # -# LC_SK_SLEEP +# LIBCFS_KSTRTOUL # -# 2.6.35 kernel has sk_sleep function +# 2.6.38 kstrtoul is added # -AC_DEFUN([LC_SK_SLEEP], [ -LB_CHECK_COMPILE([if Linux kernel has 'sk_sleep'], -sk_sleep, [ - #include +AC_DEFUN([LIBCFS_KSTRTOUL], [ +LB_CHECK_COMPILE([if Linux kernel has 'kstrtoul'], +kstrtoul, [ + #include ],[ - sk_sleep(NULL); + unsigned long result; + return kstrtoul("12345", 0, &result); ],[ - AC_DEFINE(HAVE_SK_SLEEP, 1, - [kernel has sk_sleep]) + AC_DEFINE(HAVE_KSTRTOUL, 1, + [kernel has kstrtoul]) ]) -]) # LC_SK_SLEEP +]) # LIBCFS_KSTRTOUL # # LIBCFS_DUMP_TRACE_ADDRESS @@ -184,6 +200,7 @@ dump_trace_address, [ AC_DEFUN([LC_SHRINK_CONTROL], [ LB_CHECK_COMPILE([if 'shrink_control' is present], shrink_control, [ + #include #include ],[ struct shrink_control tmp = {0}; @@ -222,30 +239,6 @@ i_uid_read, [ ]) # LIBCFS_I_UID_READ # -# LIBCFS_SOCK_ALLOC_FILE -# -# FC18 3.7.2-201 unexport sock_map_fd() change to -# use sock_alloc_file(). -# upstream commit 56b31d1c9f1e6a3ad92e7bfe252721e05d92b285 -# -AC_DEFUN([LIBCFS_SOCK_ALLOC_FILE], [ -LB_CHECK_EXPORT([sock_alloc_file], [net/socket.c], [ - LB_CHECK_COMPILE([if 'sock_alloc_file' takes 3 arguments], - sock_alloc_file_3args, [ - #include - ],[ - sock_alloc_file(NULL, 0, NULL); - ],[ - AC_DEFINE(HAVE_SOCK_ALLOC_FILE_3ARGS, 1, - [sock_alloc_file takes 3 arguments]) - ],[ - AC_DEFINE(HAVE_SOCK_ALLOC_FILE, 1, - [sock_alloc_file is exported]) - ]) -]) -]) # LIBCFS_SOCK_ALLOC_FILE - -# # LIBCFS_HAVE_CRC32 # AC_DEFUN([LIBCFS_HAVE_CRC32], [ @@ -264,10 +257,7 @@ 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 -])]) + AC_MSG_WARN([No crc32 pclmulqdq crypto api found, enable internal pclmulqdq based crc32])]) ]) # LIBCFS_ENABLE_CRC32_ACCEL # @@ -278,13 +268,125 @@ 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 -])]) + 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 +],[ + struct timespec64 *ts = NULL; + + ktime_get_ts64(ts); +],[ + AC_DEFINE(HAVE_KTIME_GET_TS64, 1, + ['ktime_get_ts64' is available]) +]) +]) # LIBCFS_KTIME_GET_TS64 + +# +# 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 +],[ + struct kernel_param_ops ops; + + ops.set = NULL; +],[ + AC_DEFINE(HAVE_KERNEL_PARAM_OPS, 1, + ['struct kernel_param_ops' is available]) +]) +]) # LIBCFS_KERNEL_PARAM_OPS + +# +# Kernel version 3.12 introduced ktime_add +# +AC_DEFUN([LIBCFS_KTIME_ADD],[ +LB_CHECK_COMPILE([does function 'ktime_add' exist], +ktime_add, [ + #include + #include +],[ + ktime_t start = ktime_set(0, 0); + ktime_t end = start; + ktime_t total; + + total = ktime_add(start, end); +],[ + AC_DEFINE(HAVE_KTIME_ADD, 1, + [ktime_add is available]) +]) +]) # LIBCFS_KTIME_ADD + +# +# Kernel version 3.12 introduced ktime_after +# +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; + + ktime_after(start, end); +],[ + AC_DEFINE(HAVE_KTIME_AFTER, 1, + [ktime_after is available]) +]) +]) # LIBCFS_KTIME_AFTER + +# +# 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 +],[ + ktime_t start = ktime_set(0, 0); + ktime_t end = start; + + ktime_before(start, end); +],[ + AC_DEFINE(HAVE_KTIME_BEFORE, 1, + [ktime_before is available]) +]) +]) # LIBCFS_KTIME_BEFORE + +# +# Kernel version 3.12 introduced ktime_compare +# +AC_DEFUN([LIBCFS_KTIME_COMPARE],[ +LB_CHECK_COMPILE([does function 'ktime_compare' exist], +ktime_compare, [ + #include + #include +],[ + ktime_t start = ktime_set(0, 0); + ktime_t end = start; + + ktime_compare(start, end); +],[ + AC_DEFINE(HAVE_KTIME_COMPARE, 1, + [ktime_compare is available]) +]) +]) # LIBCFS_KTIME_COMPARE + +# # FC19 3.12 kernel struct shrinker change # AC_DEFUN([LIBCFS_SHRINKER_COUNT],[ @@ -293,12 +395,486 @@ shrinker_count_objects, [ #include #include ],[ - ((struct shrinker*)0)->count_objects(NULL, NULL); + struct shrinker shrinker; + + shrinker.count_objects = NULL; ],[ AC_DEFINE(HAVE_SHRINKER_COUNT, 1, - [shrinker has count_objects memeber]) + [shrinker has count_objects member]) +]) +]) # LIBCFS_SHRINKER_COUNT + +# +# 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 +],[ + hlist_add_after(NULL, NULL); +],[ + AC_DEFINE(HAVE_HLIST_ADD_AFTER, 1, + [hlist_add_after is available]) +]) +]) # LIBCFS_HLIST_ADD_AFTER + +# +# Kernel version 3.17 introduced struct timespec64 +# +AC_DEFUN([LIBCFS_TIMESPEC64],[ +LB_CHECK_COMPILE([does 'struct timespec64' exist], +timespec64, [ + #include +],[ + struct timespec64 ts; + + ts.tv_sec = 0; + ts.tv_nsec = 0; +],[ + AC_DEFINE(HAVE_TIMESPEC64, 1, + ['struct timespec64' is available]) +]) +]) # LIBCFS_TIMESPEC64 + +# +# 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 +],[ + struct timespec64 *ts = NULL; + + ktime_get_real_ts64(ts); +],[ + AC_DEFINE(HAVE_KTIME_GET_REAL_TS64, 1, + ['ktime_get_real_ts64' is available]) +]) +]) # LIBCFS_KTIME_GET_REAL_TS64 + +# +# 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 +],[ + time64_t now; + + now = ktime_get_real_seconds(); +],[ + 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 + +# +# 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 +],[ + 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 +],[ + ktime_t now = ktime_set(0, 0); + struct timespec64 ts; + + ts = ktime_to_timespec64(now); +],[ + AC_DEFINE(HAVE_KTIME_TO_TIMESPEC64, 1, + ['ktime_to_timespec64' is available]) +]) +]) # LIBCFS_KTIME_TO_TIMESPEC64 + +# +# Kernel version 3.17 introduced timespec64_sub +# +AC_DEFUN([LIBCFS_TIMESPEC64_SUB],[ +LB_CHECK_COMPILE([does function 'timespec64_sub' exist], +timespec64_sub, [ + #include +],[ + struct timespec64 later = { }, earlier = { }, diff; + + diff = timespec64_sub(later, earlier); +],[ + 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; + + now = timespec64_to_ktime(ts); +],[ + AC_DEFINE(HAVE_TIMESPEC64_TO_KTIME, 1, + ['timespec64_to_ktime' is available]) +]) +]) # LIBCFS_TIMESPEC64_TO_KTIME + +# +# 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 +],[ + time64_t now; + + now = ktime_get_seconds(); +],[ + 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 + +# +# 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 +],[ + ktime_t start = ktime_set(0, 0); + ktime_t end = start; + + ktime_ms_delta(start, end); +],[ + 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_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 + +# +# Kernel version 4.2 commit df6b35f409af0a8ff1ef62f552b8402f3fef8665 +# header file i387.h was renamed to fpu/api.h +# +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 + +# +# 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 + +# +# 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 +],[ + int rc; + + rc = ((struct stacktrace_ops *)0)->address(NULL, 0, 0); +],[ + AC_DEFINE(STACKTRACE_OPS_ADDRESS_RETURN_INT, 1, + ['struct stacktrace_ops' address function returns an int]) +]) +]) # LIBCFS_STACKTRACE_OPS_ADDRESS_RETURN_INT + +# +# 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 +],[ + int rc; + + rc = get_user_pages(0, 0, 0, 0, NULL, NULL); +],[ + AC_DEFINE(HAVE_GET_USER_PAGES_6ARG, 1, + [get_user_pages takes 6 arguments]) ]) +]) # LIBCFS_GET_USER_PAGES_6ARG + +# +# LIBCFS_STACKTRACE_OPS +# +# 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; +],[ + AC_DEFINE(HAVE_STACKTRACE_OPS, 1, + [struct stacktrace_ops exists]) ]) +]) # LIBCFS_STACKTRACE_OPS + +# +# 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 +],[ + int rc; + rc = get_user_pages(0, 0, FOLL_WRITE, NULL, NULL); +],[ + 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 + +# +# LIBCFS_SCHED_HEADERS +# +# 4.11 has broken up sched.h into more headers. +# +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 +],[ + wait_queue_entry_t e; + + e.flags = 0; +],[ + AC_DEFINE(HAVE_WAIT_QUEUE_ENTRY, 1, + ['wait_queue_entry_t' is available]) +]) +]) # LIBCFS_WAIT_QUEUE_ENTRY + +# +# LIBCFS_NEW_KERNEL_WRITE +# +# Kernel version 4.14 e13ec939e96b13e664bb6cee361cc976a0ee621a +# changed kernel_write prototype to make is plug compatible +# with the unexported vfs_write() +# +AC_DEFUN([LIBCFS_NEW_KERNEL_WRITE], [ +tmp_flags="$EXTRA_KCFLAGS" +EXTRA_KCFLAGS="-Werror" +LB_CHECK_COMPILE([if 'kernel_write' matches other read/write helpers], +kernel_write_match, [ + #include +],[ + const void *buf = NULL; + loff_t pos = 0; + return kernel_write(NULL, buf, 0, &pos); +],[ + AC_DEFINE(HAVE_NEW_KERNEL_WRITE, 1, + ['kernel_write' aligns with read/write helpers]) +]) +EXTRA_KCFLAGS="$tmp_flags" +]) # LIBCFS_NEW_KERNEL_WRITE + +# +# LIBCFS_TIMER_SETUP +# +# 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_TIMER_SETUP], [ +LB_CHECK_COMPILE([if setup_timer has been replaced with timer_setup], +timer_setup, [ + #include +],[ + timer_setup(NULL, NULL, 0); +],[ + AC_DEFINE(HAVE_TIMER_SETUP, 1, + [timer_setup has replaced setup_timer]) +]) +]) # LIBCFS_TIMER_SETUP # # LIBCFS_PROG_LINUX @@ -315,28 +891,76 @@ LIBCFS_STACKTRACE_OPS_HAVE_WALK_STACK LC_SHRINKER_WANT_SHRINK_PTR # 2.6.33 LIBCFS_SYSCTL_CTLNAME -# 2.6.34 -LIBCFS_ADD_WAIT_QUEUE_EXCLUSIVE -# 2.6.35 -LC_SK_SLEEP +# 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.7 -LIBCFS_SOCK_ALLOC_FILE # 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 # @@ -356,46 +980,31 @@ AC_DEFUN([LIBCFS_CONFIGURE], [ AC_MSG_NOTICE([LibCFS core checks ==============================================================================]) -# 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]) - -# lnet/libcfs/user-prim.c, missing for RHEL5 and earlier userspace -AC_CHECK_FUNCS([strlcpy]) - -# libcfs/libcfs/user-prim.c, missing for RHEL5 and earlier userspace -AC_CHECK_FUNCS([strlcat]) +# libcfs/libcfs/util/nidstrings.c +AC_CHECK_HEADERS([netdb.h asm/types.h endian.h]) +AC_CHECK_FUNCS([gethostbyname]) # -------- Check for required packages -------------- AC_MSG_NOTICE([LibCFS required packages checks ==============================================================================]) -AC_MSG_CHECKING([whether to enable 'efence' debugging support]) -AC_ARG_ENABLE(efence, - AC_HELP_STRING([--enable-efence], - [use efence library]), - [], [enable_efence="no"]) -AC_MSG_RESULT([$enable_efence]) -AS_IF([test "$enable_efence" = yes], [ - LIBEFENCE="-lefence" - AC_DEFINE(HAVE_LIBEFENCE, 1, [libefence support is requested]) -], [ - LIBEFENCE="" -]) -AC_SUBST(LIBEFENCE) +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]) -# -------- check for -lpthread support ---- +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) AC_MSG_CHECKING([whether to use libpthread for libcfs library]) AC_ARG_ENABLE([libpthread], @@ -403,22 +1012,18 @@ AC_ARG_ENABLE([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], - [ENABLE_LIBPTHREAD="yes"], - [ENABLE_LIBPTHREAD="no"]) - AS_IF([test "$ENABLE_LIBPTHREAD" = yes], [ + AC_CHECK_LIB([pthread], [pthread_create], [ PTHREAD_LIBS="-lpthread" - AC_DEFINE([HAVE_LIBPTHREAD], 1, [use libpthread]) - ], [ - PTHREAD_LIBS="" + AC_DEFINE([HAVE_LIBPTHREAD], 1, + [use libpthread for libcfs library]) ]) - AC_SUBST(PTHREAD_LIBS) ], [ AC_MSG_WARN([Using libpthread for libcfs library is disabled explicitly]) - ENABLE_LIBPTHREAD="no" ]) -AC_SUBST(ENABLE_LIBPTHREAD) +AC_SUBST(PTHREAD_LIBS) ]) # LIBCFS_CONFIGURE # @@ -437,14 +1042,12 @@ AM_CONDITIONAL(NEED_PCLMULQDQ_CRC32C, [test "x$enable_crc32c_crypto" = xyes]) # AC_DEFUN([LIBCFS_CONFIG_FILES], [ AC_CONFIG_FILES([ -libcfs/Kernelenv 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