X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=libcfs%2Fautoconf%2Flustre-libcfs.m4;h=8ff37b5d666e55e871b98b6d788f85480e17e6b6;hb=353e3c2f8d9f195c0f87a16259f22b2f84de11d4;hp=c200cae23555730eaccec2f4304c57ae78185a15;hpb=e74027abc8096372b4fee512d715c94171cb6e60;p=fs%2Flustre-release.git diff --git a/libcfs/autoconf/lustre-libcfs.m4 b/libcfs/autoconf/lustre-libcfs.m4 index c200cae..8ff37b5 100644 --- a/libcfs/autoconf/lustre-libcfs.m4 +++ b/libcfs/autoconf/lustre-libcfs.m4 @@ -59,217 +59,64 @@ else fi ]) -# -# LIBCFS_STRUCT_PAGE_LIST -# -# 2.6.4 no longer has page->list -# -AC_DEFUN([LIBCFS_STRUCT_PAGE_LIST], -[AC_MSG_CHECKING([if struct page has a list field]) +# check kernel __u64 type +AC_DEFUN([LIBCFS_U64_LONG_LONG_LINUX], +[ +AC_MSG_CHECKING([kernel __u64 is long long type]) +tmp_flags="$EXTRA_KCFLAGS" +EXTRA_KCFLAGS="$EXTRA_KCFLAGS -Werror" LB_LINUX_TRY_COMPILE([ - #include -],[ - struct page page; - &page.list; -],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_PAGE_LIST, 1, [struct page has a list field]) + #include + #include ],[ - AC_MSG_RESULT([no]) -]) -]) + unsigned long long *data; -# -# LIBCFS_STRUCT_SIGHAND -# -# red hat 2.4 adds sighand to struct task_struct -# -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; + data = (__u64*)sizeof(data); ],[ - AC_DEFINE(CONFIG_RH_2_4_20, 1, [this kernel contains Red Hat 2.4.20 patches]) AC_MSG_RESULT([yes]) + AC_DEFINE(HAVE_KERN__U64_LONG_LONG, 1, + [kernel __u64 is long long type]) ],[ AC_MSG_RESULT([no]) ]) +EXTRA_KCFLAGS="$tmp_flags" ]) -# -# LIBCFS_FUNC_CPU_ONLINE -# -# cpu_online is different in rh 2.4, vanilla 2.4, and 2.6 -# -AC_DEFUN([LIBCFS_FUNC_CPU_ONLINE], -[AC_MSG_CHECKING([if kernel defines cpu_online()]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - cpu_online(0); -],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_CPU_ONLINE, 1, [cpu_online found]) -],[ - AC_MSG_RESULT([no]) -]) -]) - -# -# LIBCFS_TYPE_GFP_T -# -# check if gfp_t is typedef-ed -# -AC_DEFUN([LIBCFS_TYPE_GFP_T], -[AC_MSG_CHECKING([if kernel defines gfp_t]) -LB_LINUX_TRY_COMPILE([ - #include -],[ - return sizeof(gfp_t); -],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_GFP_T, 1, [gfp_t found]) +# 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]) ],[ - AC_MSG_RESULT([no]) ]) ]) +# LIBCFS_DIGEST_SETKEY_FLAGS +# digest_alg.dia_setkey takes 4 args (2.6.18) # -# LIBCFS_TYPE_CPUMASK_T -# -# same goes for cpumask_t -# -AC_DEFUN([LIBCFS_TYPE_CPUMASK_T], -[AC_MSG_CHECKING([if kernel defines cpumask_t]) +AC_DEFUN([LIBCFS_DIGEST_SETKEY_FLAGS], +[AC_MSG_CHECKING([if kernel dia_setkey takes 4 args]) LB_LINUX_TRY_COMPILE([ - #include -],[ - return sizeof (cpumask_t); -],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_CPUMASK_T, 1, [cpumask_t found]) -],[ - AC_MSG_RESULT([no]) -]) -]) + #include + #include -# -# LIBCFS_FUNC_SHOW_TASK -# -# we export show_task(), but not all kernels have it (yet) -# -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]) -],[ -]) -]) - -# check userland __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 - int main(void) { - unsigned long long *data1; - __u64 *data2; - - data1 = data2; - return 0; - } -],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_U64_LONG_LONG, 1, - [__u64 is long long type]) -],[ - AC_MSG_RESULT([no]) -]) -CFLAGS="$tmp_flags" -]) - -# check userland size_t type -AC_DEFUN([LIBCFS_SIZE_T_LONG], -[AC_MSG_CHECKING([size_t is unsigned long type]) -tmp_flags="$CFLAGS" -CFLAGS="$CFLAGS -Werror" -AC_COMPILE_IFELSE([ - #include - int main(void) { - unsigned long *data1; - size_t *data2; - - data1 = data2; - return 0; + static int foo(struct crypto_tfm *tfm, const u8 *key, unsigned int l, u32* f) + { + return 1; } ],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_SIZE_T_LONG, 1, - [size_t is long type]) -],[ - AC_MSG_RESULT([no]) -]) -CFLAGS="$tmp_flags" -]) - -AC_DEFUN([LIBCFS_SSIZE_T_LONG], -[AC_MSG_CHECKING([ssize_t is signed long type]) -tmp_flags="$CFLAGS" -CFLAGS="$CFLAGS -Werror" -AC_COMPILE_IFELSE([ - #include - int main(void) { - long *data1; - ssize_t *data2; - - data1 = data2; - return 0; - } + struct digest_alg alg = {.dia_setkey=foo}; ],[ AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_SSIZE_T_LONG, 1, - [ssize_t is long type]) + AC_DEFINE(HAVE_DIGEST_SETKEY_FLAGS, 1, [kernel dia_setkey takes 4 args]) ],[ AC_MSG_RESULT([no]) ]) -CFLAGS="$tmp_flags" ]) -# 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; - - tsk.rcu.next = NULL; -],[ - AC_MSG_RESULT([yes]) - AC_DEFINE(HAVE_TASK_RCU, 1, - [task_struct has rcu field]) -],[ - AC_MSG_RESULT([no]) -]) -]) - -# 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]) -],[ -]) -]) - # 2.6.19 API changes # kmem_cache_destroy(cachep) return void instead of # int @@ -278,7 +125,8 @@ AC_DEFUN([LIBCFS_KMEM_CACHE_DESTROY_INT], LB_LINUX_TRY_COMPILE([ #include ],[ - int i = kmem_cache_destroy(NULL); + int i __attribute__ ((unused)); + i = kmem_cache_destroy(NULL); ],[ AC_MSG_RESULT(yes) AC_DEFINE(HAVE_KMEM_CACHE_DESTROY_INT, 1, @@ -288,25 +136,117 @@ LB_LINUX_TRY_COMPILE([ ]) ]) -# 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]) +# check cpumask_size (2.6.28) +AC_DEFUN([LIBCFS_CPUMASK_SIZE], +[AC_MSG_CHECKING([whether have cpumask_size()]) LB_LINUX_TRY_COMPILE([ - #include - #include + #include ],[ - struct atomic_notifier_head panic_notifier_list; + int size = cpumask_size(); ],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_ATOMIC_PANIC_NOTIFIER, 1, - [panic_notifier_list is atomic_notifier_head]) + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_CPUMASK_SIZE, 1, [have cpumask_size()]) ],[ - AC_MSG_RESULT(NO) + AC_MSG_RESULT(NO) ]) ]) +# check cpu topology functions +# +# topology_core_cpumask (2.6.29, not on all archs) +# topology_core_siblings (not on all archs) +# topology_thread_cpumask (2.6.29, not on all archs) +# topology_thread_siblings (not on all archs) +# cpumask_of_node/node_to_cpumask (not always exported) +AC_DEFUN([LIBCFS_CPU_TOPOLOGY], +[AC_MSG_CHECKING([whether have topology.h]) +LB_LINUX_TRY_COMPILE([ + #include +],[],[ + AC_DEFINE(HAVE_CPU_TOPOLOGY, 1, [have CPU topology]) + AC_MSG_RESULT(yes) + + AC_MSG_CHECKING([whether have topology_core_cpumask]) + LB_LINUX_TRY_COMPILE([ + #include + ],[ + cpumask_t *mask = topology_core_cpumask(0); + ],[ + AC_DEFINE(HAVE_TOPOLOGY_CORE_CPUMASK, 1, + [have topology_core_cpumask]) + AC_MSG_RESULT(yes) + ],[ + AC_MSG_RESULT(no) + ]) + + AC_MSG_CHECKING([whether have topology_core_siblings]) + LB_LINUX_TRY_COMPILE([ + #include + ],[ + cpumask_t mask = topology_core_siblings(0); + ],[ + AC_DEFINE(HAVE_TOPOLOGY_CORE_SIBLINGS, 1, + [have topology_core_siblings]) + AC_MSG_RESULT(yes) + ],[ + AC_MSG_RESULT(no) + ]) + + AC_MSG_CHECKING([whether have topology_thread_cpumask]) + LB_LINUX_TRY_COMPILE([ + #include + ],[ + cpumask_t *mask = topology_thread_cpumask(0); + ],[ + AC_DEFINE(HAVE_TOPOLOGY_THREAD_CPUMASK, 1, + [have topology_thread_cpumask]) + AC_MSG_RESULT(yes) + ],[ + AC_MSG_RESULT(no) + ]) + + AC_MSG_CHECKING([whether have topology_thread_siblings]) + LB_LINUX_TRY_COMPILE([ + #include + ],[ + cpumask_t mask = topology_thread_siblings(0); + ],[ + AC_DEFINE(HAVE_TOPOLOGY_THREAD_SIBLINGS, 1, + [have topology_thread_siblings]) + AC_MSG_RESULT(yes) + ],[ + AC_MSG_RESULT(no) + ]) + + AC_MSG_CHECKING([whether have cpumask_of_node]) + LB_LINUX_TRY_COMPILE([ + #include + ],[ + cpumask_t *mask = cpumask_of_node(0); + ],[ + AC_DEFINE(HAVE_CPUMASK_OF_NODE, 1, [have cpumask_of_node]) + AC_MSG_RESULT(yes) + ],[ + AC_MSG_RESULT(no) + ]) + + AC_MSG_CHECKING([whether have node_to_cpumask]) + LB_LINUX_TRY_COMPILE([ + #include + ],[ + cpumask_t mask = node_to_cpumask(0); + ],[ + AC_DEFINE(HAVE_NODE_TO_CPUMASK, 1, [have node_to_cpumask]) + AC_MSG_RESULT(yes) + ],[ + AC_MSG_RESULT(no) + ]) +],[ + AC_MSG_RESULT(NO) +]) +]) + + # 2.6.20 API change INIT_WORK use 2 args and not # store data inside AC_DEFUN([LIBCFS_3ARGS_INIT_WORK], @@ -314,7 +254,7 @@ AC_DEFUN([LIBCFS_3ARGS_INIT_WORK], LB_LINUX_TRY_COMPILE([ #include ],[ - struct work_struct work; + struct work_struct work __attribute__ ((unused)); INIT_WORK(&work, NULL, NULL); ],[ @@ -333,7 +273,7 @@ AC_DEFUN([LIBCFS_2ARGS_REGISTER_SYSCTL], LB_LINUX_TRY_COMPILE([ #include ],[ - return register_sysctl_table(NULL,0); + register_sysctl_table(NULL,0); ],[ AC_MSG_RESULT(yes) AC_DEFINE(HAVE_2ARGS_REGISTER_SYSCTL, 1, @@ -343,28 +283,6 @@ LB_LINUX_TRY_COMPILE([ ]) ]) -# 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; -],[ - cache_t *cachep = NULL; - - kmem_cache_alloc(cachep, 0); -],[ - AC_MSG_RESULT(yes) - AC_DEFINE(HAVE_KMEM_CACHE, 1, - [kernel has struct kmem_cache]) -],[ - AC_MSG_RESULT(NO) -]) -EXTRA_KCFLAGS="$tmp_flags" -]) # 2.6.23 lost dtor argument AC_DEFUN([LIBCFS_KMEM_CACHE_CREATE_DTOR], [AC_MSG_CHECKING([check kmem_cache_create has dtor argument]) @@ -381,8 +299,24 @@ LB_LINUX_TRY_COMPILE([ ]) ]) +#2.6.23 has new shrinker API +AC_DEFUN([LC_REGISTER_SHRINKER], +[AC_MSG_CHECKING([if kernel has register_shrinker]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + register_shrinker(NULL); +], [ + AC_MSG_RESULT([yes]) + AC_DEFINE(HAVE_REGISTER_SHRINKER, 1, + [kernel has register_shrinker]) +],[ + AC_MSG_RESULT([no]) +]) +]) + # 2.6.24 request not use real numbers for ctl_name -AC_DEFUN([LN_SYSCTL_UNNUMBERED], +AC_DEFUN([LIBCFS_SYSCTL_UNNUMBERED], [AC_MSG_CHECKING([for CTL_UNNUMBERED]) LB_LINUX_TRY_COMPILE([ #include @@ -400,9 +334,10 @@ LB_LINUX_TRY_COMPILE([ ]) # 2.6.24 lost scatterlist->page -AC_DEFUN([LN_SCATTERLIST_SETPAGE], +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); @@ -415,14 +350,105 @@ LB_LINUX_TRY_COMPILE([ ]) ]) +# 2.6.24 +AC_DEFUN([LIBCFS_NETWORK_NAMESPACE], +[AC_MSG_CHECKING([for network stack has namespaces]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + struct net *net __attribute__ ((unused)); + net = &init_net; +],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_INIT_NET, 1, + [kernel is support network namespaces ]) +],[ + AC_MSG_RESULT(NO) +]) +]) + +# +# LIBCFS_FUNC_DUMP_TRACE +# +# 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_FUNC_DUMP_TRACE], +[LB_CHECK_SYMBOL_EXPORT([dump_trace], +[kernel/ksyms.c arch/${LINUX_ARCH%_64}/kernel/traps_64.c arch/x86/kernel/dumpstack_32.c arch/x86/kernel/dumpstack_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; + #include + ],[ + ((struct stacktrace_ops *)0)->address(NULL, 0, 0); + ],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_TRACE_ADDRESS_RELIABLE, 1, + [print_trace_address has reliable argument]) + ],[ + AC_MSG_RESULT(no) + ],[ + ]) + AC_MSG_CHECKING([whether stacktrace_ops.warning is exist]) + LB_LINUX_TRY_COMPILE([ + struct task_struct; + struct pt_regs; + #include + ],[ + ((struct stacktrace_ops *)0)->warning(NULL, NULL); + ],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_STACKTRACE_WARNING, 1, [stacktrace_ops.warning is exist]) + ],[ + AC_MSG_RESULT(no) + ],[ + ]) + AC_MSG_CHECKING([dump_trace want address]) + LB_LINUX_TRY_COMPILE([ + struct task_struct; + struct pt_regs; + #include + ],[ + dump_trace(NULL, NULL, NULL, 0, NULL, NULL); + ],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_DUMP_TRACE_ADDRESS, 1, + [dump_trace want address argument]) + ],[ + AC_MSG_RESULT(no) + ],[ + ]) + +EXTRA_KCFLAGS="$tmp_flags" +]) +]) + + # 2.6.26 use int instead of atomic for sem.count -AC_DEFUN([LN_SEM_COUNT], +AC_DEFUN([LIBCFS_SEM_COUNT], [AC_MSG_CHECKING([atomic sem.count]) LB_LINUX_TRY_COMPILE([ #include ],[ - struct semaphore s; - + struct semaphore s __attribute__ ((unused)); + atomic_read(&s.count); ],[ AC_MSG_RESULT(yes) @@ -433,6 +459,290 @@ LB_LINUX_TRY_COMPILE([ ]) ]) +# 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); +],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_SOCK_MAP_FD_2ARG, 1, + [sock_map_fd have second argument]) +],[ + AC_MSG_RESULT(NO) +]) +]) + +# LIBCFS_CRED_WRAPPERS +# +# wrappers for task's credentials are in sles11 +# +AC_DEFUN([LIBCFS_CRED_WRAPPERS], +[AC_MSG_CHECKING([if kernel has wrappers for task's credentials]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + uid_t uid; + + uid = current_uid() + sizeof(uid); +],[ + AC_MSG_RESULT([yes]) + AC_DEFINE(HAVE_CRED_WRAPPERS, 1, [task's cred wrappers found]) +],[ + AC_MSG_RESULT([no]) +]) +]) + +# +# LN_STRUCT_CRED_IN_TASK +# +# struct cred was introduced in 2.6.29 to streamline credentials in task struct +# +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_MSG_RESULT([yes]) + AC_DEFINE(HAVE_STRUCT_CRED, 1, [struct cred found]) +],[ + AC_MSG_RESULT([no]) +]) +]) + +# LIBCFS_STRUCT_SHASH_ALG +# struct shash_alg was introduced in 2.6.29 +# +AC_DEFUN([LIBCFS_STRUCT_SHASH_ALG], +[AC_MSG_CHECKING([if kernel has struct shash_alg]) +LB_LINUX_TRY_COMPILE([ + #include + #include +],[ + struct shash_alg foo; +],[ + AC_MSG_RESULT([yes]) + AC_DEFINE(HAVE_STRUCT_SHASH_ALG, 1, [kernel has struct shash_alg]) +],[ + AC_MSG_RESULT([no]) +]) +]) + + +# +# LIBCFS_FUNC_UNSHARE_FS_STRUCT +# +# unshare_fs_struct was introduced in 2.6.30 to prevent others to directly +# mess with copy_fs_struct +# +AC_DEFUN([LIBCFS_FUNC_UNSHARE_FS_STRUCT], +[AC_MSG_CHECKING([if kernel defines unshare_fs_struct()]) +tmp_flags="$EXTRA_KCFLAGS" +EXTRA_KCFLAGS="-Werror" +LB_LINUX_TRY_COMPILE([ + #include + #include +],[ + unshare_fs_struct(); +],[ + AC_MSG_RESULT([yes]) + AC_DEFINE(HAVE_UNSHARE_FS_STRUCT, 1, [unshare_fs_struct found]) +],[ + AC_MSG_RESULT([no]) +]) +EXTRA_KCFLAGS="$tmp_flags" +]) + +# +# LIBCFS_HAVE_IS_COMPAT_TASK +# +# Added in 2.6.17, it wasn't until 2.6.29 that all +# Linux architectures have is_compat_task() +# +AC_DEFUN([LIBCFS_HAVE_IS_COMPAT_TASK], +[AC_MSG_CHECKING([if is_compat_task() is declared]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + int i __attribute__ ((unused)); + i = is_compat_task(); +],[ + AC_MSG_RESULT([yes]) + AC_DEFINE(HAVE_IS_COMPAT_TASK, 1, [is_compat_task() is available]) +],[ + AC_MSG_RESULT([no]) +]) +]) + +# +# LIBCFS_STACKTRACE_OPS_HAVE_WALK_STACK +# +# 2.6.32-30.el6 adds a new 'walk_stack' field in 'struct stacktrace_ops' +# +AC_DEFUN([LIBCFS_STACKTRACE_OPS_HAVE_WALK_STACK], +[AC_MSG_CHECKING([if 'struct stacktrace_ops' has 'walk_stack' field]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + ((struct stacktrace_ops *)0)->walk_stack(NULL, NULL, 0, NULL, NULL, NULL, NULL); +],[ + AC_MSG_RESULT([yes]) + AC_DEFINE(STACKTRACE_OPS_HAVE_WALK_STACK, 1, ['struct stacktrace_ops' has 'walk_stack' field]) +],[ + AC_MSG_RESULT([no]) +]) +]) + +AC_DEFUN([LIBCFS_HAVE_OOM_H], +[LB_CHECK_FILE([$LINUX/include/linux/oom.h], [ + AC_DEFINE(HAVE_LINUX_OOM_H, 1, + [kernel has include/oom.h]) +],[ + AC_MSG_RESULT([no]) +]) +]) + +# +# check set_mems_allowed +# 2.6.31 adds function set_mems_allowed in cpuset.h +# +AC_DEFUN([LIBCFS_HAVE_SET_MEMS_ALLOWED], +[AC_MSG_CHECKING([whether have set_mems_allowed()]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + nodemask_t mask; + + set_mems_allowed(mask); +],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_SET_MEMS_ALLOWED, 1, [have set_mems_allowed()]) +],[ + AC_MSG_RESULT(NO) +]) +]) + + +# +# RHEL6/2.6.32 want to have pointer to shrinker self pointer in handler function +# +AC_DEFUN([LC_SHRINKER_WANT_SHRINK_PTR], +[AC_MSG_CHECKING([shrinker want self pointer in handler]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + struct shrinker *tmp = NULL; + tmp->shrink(tmp, 0, 0); +],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_SHRINKER_WANT_SHRINK_PTR, 1, + [shrinker want self pointer in handler]) +],[ + AC_MSG_RESULT(no) +]) +]) + +# 2.6.18 store oom parameters in task struct. +# 2.6.32 store oom parameters in signal struct +AC_DEFUN([LIBCFS_OOMADJ_IN_SIG], +[AC_MSG_CHECKING([kernel store oom parameters in task]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + ((struct signal_struct *)0)->oom_adj = 0; +],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_OOMADJ_IN_SIG, 1, + [kernel store a oom parameters in signal struct]) +],[ + AC_MSG_RESULT(no) +]) +]) + +# +# 2.6.33 no longer has ctl_name & strategy field in struct ctl_table. +# +AC_DEFUN([LIBCFS_SYSCTL_CTLNAME], +[AC_MSG_CHECKING([if ctl_table has a ctl_name field]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + struct ctl_table ct; + ct.ctl_name = sizeof(ct); +],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_SYSCTL_CTLNAME, 1, + [ctl_table has ctl_name field]) +],[ + AC_MSG_RESULT(no) +]) +]) + +# +# LIBCFS_ADD_WAIT_QUEUE_EXCLUSIVE +# +# 2.6.34 adds __add_wait_queue_exclusive +# +AC_DEFUN([LIBCFS_ADD_WAIT_QUEUE_EXCLUSIVE], +[AC_MSG_CHECKING([if __add_wait_queue_exclusive exists]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + wait_queue_head_t queue; + wait_queue_t wait; + + __add_wait_queue_exclusive(&queue, &wait); +],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE___ADD_WAIT_QUEUE_EXCLUSIVE, 1, + [__add_wait_queue_exclusive exists]) +],[ + AC_MSG_RESULT(no) +]) +]) + +# +# 2.6.35 kernel has sk_sleep function +# +AC_DEFUN([LC_SK_SLEEP], +[AC_MSG_CHECKING([if kernel has sk_sleep]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + sk_sleep(NULL); +],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_SK_SLEEP, 1, [kernel has sk_sleep]) +],[ + AC_MSG_RESULT(no) +]) +]) + +# +# FC15 2.6.40-5 backported the "shrink_control" parameter to the memory +# pressure shrinker from Linux 3.0 +# +AC_DEFUN([LC_SHRINK_CONTROL], +[AC_MSG_CHECKING([shrink_control is present]) +LB_LINUX_TRY_COMPILE([ + #include +],[ + struct shrink_control tmp = {0}; + tmp.nr_to_scan = sizeof(tmp); +],[ + AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_SHRINK_CONTROL, 1, + [shrink_control is present]) +],[ + AC_MSG_RESULT(no) +]) +]) + # # LIBCFS_PROG_LINUX # @@ -440,35 +750,55 @@ LB_LINUX_TRY_COMPILE([ # AC_DEFUN([LIBCFS_PROG_LINUX], [ -LIBCFS_FUNC_CPU_ONLINE -LIBCFS_TYPE_GFP_T -LIBCFS_TYPE_CPUMASK_T LIBCFS_CONFIG_PANIC_DUMPLOG -LIBCFS_STRUCT_PAGE_LIST -LIBCFS_STRUCT_SIGHAND -LIBCFS_FUNC_SHOW_TASK -LIBCFS_U64_LONG_LONG -LIBCFS_SSIZE_T_LONG -LIBCFS_SIZE_T_LONG -LIBCFS_TASK_RCU +LIBCFS_U64_LONG_LONG_LINUX # 2.6.18 LIBCFS_TASKLIST_LOCK +LIBCFS_HAVE_IS_COMPAT_TASK +LIBCFS_DIGEST_SETKEY_FLAGS # 2.6.19 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 +LC_REGISTER_SHRINKER # 2.6.24 -LN_SYSCTL_UNNUMBERED -LN_SCATTERLIST_SETPAGE +LIBCFS_SYSCTL_UNNUMBERED +LIBCFS_SCATTERLIST_SETPAGE +LIBCFS_NETWORK_NAMESPACE +LIBCFS_FUNC_DUMP_TRACE # 2.6.26 -LN_SEM_COUNT +LIBCFS_SEM_COUNT +# 2.6.27 +LIBCFS_CRED_WRAPPERS +# 2.6.28 +LIBCFS_CPUMASK_SIZE +# 2.6.29 +LIBCFS_STRUCT_CRED_IN_TASK +LIBCFS_CPU_TOPOLOGY +LIBCFS_STRUCT_SHASH_ALG +# 2.6.30 +LIBCFS_FUNC_UNSHARE_FS_STRUCT +LIBCFS_SOCK_MAP_FD_2ARG +# 2.6.31 +LIBCFS_HAVE_SET_MEMS_ALLOWED +# 2.6.32 +LIBCFS_STACKTRACE_OPS_HAVE_WALK_STACK +LC_SHRINKER_WANT_SHRINK_PTR +LIBCFS_HAVE_OOM_H +LIBCFS_OOMADJ_IN_SIG +# 2.6.33 +LIBCFS_SYSCTL_CTLNAME +# 2.6.34 +LIBCFS_ADD_WAIT_QUEUE_EXCLUSIVE +# 2.6.35 +LC_SK_SLEEP +# 2.6.40 fc15 +LC_SHRINK_CONTROL ]) # @@ -512,17 +842,71 @@ AC_CHECK_FUNCS([strnlen]) AC_CHECK_TYPE([umode_t], [AC_DEFINE(HAVE_UMODE_T, 1, [umode_t is defined])], [], - [#include ]) + [#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 ]) + [#include ]) AC_CHECK_TYPE([__s64], [AC_DEFINE(HAVE___S64, 1, [__s64 is defined])], [], - [#include ]) + [#include ]) + +# check userland __u64 type +AC_MSG_CHECKING([userspace __u64 is long long type]) +tmp_flags="$CFLAGS" +CFLAGS="$CFLAGS -Werror" +AC_COMPILE_IFELSE([ + #include + #include + #include + int main(void) { + unsigned long long *data1; + __u64 *data2 = NULL; + + data1 = data2; + return 0; + } +],[ + AC_MSG_RESULT([yes]) + AC_DEFINE(HAVE_USER__U64_LONG_LONG, 1, + [__u64 is long long type]) +],[ + AC_MSG_RESULT([no]) +]) +CFLAGS="$tmp_flags" # -------- Check for required packages -------------- @@ -600,13 +984,7 @@ libcfs/libcfs/autoMakefile libcfs/libcfs/linux/Makefile libcfs/libcfs/posix/Makefile libcfs/libcfs/util/Makefile -]) -case $lb_target_os in - darwin) - AC_CONFIG_FILES([ libcfs/include/libcfs/darwin/Makefile libcfs/libcfs/darwin/Makefile ]) - ;; -esac ])