From a89d6b029d059d01b8bbfc18b9ee6e3f5a964b85 Mon Sep 17 00:00:00 2001 From: Simon Wilkinson Date: Tue, 27 Apr 2010 17:41:22 +0100 Subject: [PATCH 1/1] Linux: Add general autoconf macro for Linux kernel Add AC_CHECK_LINUX_BUILD() to do a standardised Linux build, which takes a "checking" message, the autoconf variable to use to cache the results, headers and code to run, preprocessor variable to define, and a description of that variable. Reimplement all of our existing check macros in terms of this one, resolving many typos along the way. Change-Id: I41988c83fcdbfbf8152f6dd0e7c4bd16c7a04240 Reviewed-on: http://gerrit.openafs.org/1854 Reviewed-by: Derrick Brashear Tested-by: Derrick Brashear --- acinclude.m4 | 88 +----- src/afs/LINUX/osi_nfssrv.c | 2 +- src/cf/linux-test1.m4 | 44 +-- src/cf/linux-test4.m4 | 717 ++++++++++++++++++++------------------------- 4 files changed, 348 insertions(+), 503 deletions(-) diff --git a/acinclude.m4 b/acinclude.m4 index 6cbf974..ded13ed 100644 --- a/acinclude.m4 +++ b/acinclude.m4 @@ -53,11 +53,8 @@ AH_BOTTOM([ #undef FAST_RESTART #undef DEFINED_FOR_EACH_PROCESS #undef DEFINED_PREV_TASK -#undef EXPORTED_KALLSYMS_SYMBOL #undef EXPORTED_SYS_CALL_TABLE #undef EXPORTED_IA32_SYS_CALL_TABLE -#undef EXPORTED_TASKLIST_LOCK -#undef INODE_SETATTR_NOT_VOID #undef IRIX_HAS_MEM_FUNCS #undef RECALC_SIGPENDING_TAKES_VOID #undef STRUCT_FS_HAS_FS_ROLLED @@ -901,7 +898,9 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*) LINUX_GET_SB_HAS_STRUCT_VFSMOUNT LINUX_STATFS_TAKES_DENTRY AC_CHECK_LINUX_HEADER([freezer.h]) - LINUX_HAVE_SVC_ADDR_IN + AC_CHECK_LINUX_FUNC([svc_addr_in], + [#include ], + [svc_addr_in(NULL);]) LINUX_REFRIGERATOR LINUX_HAVE_TRY_TO_FREEZE LINUX_LINUX_KEYRING_SUPPORT @@ -978,98 +977,17 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*) if test -f "$LINUX_KERNEL_PATH/include/linux/mm_inline.h"; then AC_DEFINE(HAVE_MM_INLINE_H, 1, [define if you have mm_inline.h header file]) fi - if test "x$ac_cv_linux_exports_sys_chdir" = "xyes" ; then - AC_DEFINE(EXPORTED_SYS_CHDIR, 1, [define if your linux kernel exports sys_chdir]) - fi - if test "x$ac_cv_linux_exports_sys_open" = "xyes" ; then - AC_DEFINE(EXPORTED_SYS_OPEN, 1, [define if your linux kernel exports sys_open]) - fi - if test "x$ac_cv_linux_exports_sys_call_table" = "xyes"; then - AC_DEFINE(EXPORTED_SYS_CALL_TABLE, 1, [define if your linux kernel exports sys_call_table]) - fi - if test "x$ac_cv_linux_exports_ia32_sys_call_table" = "xyes"; then - AC_DEFINE(EXPORTED_IA32_SYS_CALL_TABLE, 1, [define if your linux kernel exports ia32_sys_call_table]) - fi - if test "x$ac_cv_linux_exports_kallsyms_symbol" = "xyes"; then - AC_DEFINE(EXPORTED_KALLSYMS_SYMBOL, 1, [define if your linux kernel exports kallsyms]) - fi - if test "x$ac_cv_linux_exports_kallsyms_address" = "xyes"; then - AC_DEFINE(EXPORTED_KALLSYMS_ADDRESS, 1, [define if your linux kernel exports kallsyms address]) - fi if test "x$ac_cv_linux_defines_for_each_process" = "xyes" ; then AC_DEFINE(DEFINED_FOR_EACH_PROCESS, 1, [define if for_each_process defined]) fi if test "x$ac_cv_linux_defines_prev_task" = "xyes" ; then AC_DEFINE(DEFINED_PREV_TASK, 1, [define if prev_task defined]) fi - if test "x$ac_cv_linux_func_inode_setattr_returns_int" = "xyes" ; then - AC_DEFINE(INODE_SETATTR_NOT_VOID, 1, [define if your setattr return return non-void]) - fi - if test "x$ac_cv_linux_func_recalc_sigpending_takes_void" = "xyes"; then - AC_DEFINE(RECALC_SIGPENDING_TAKES_VOID, 1, [define if your recalc_sigpending takes void]) - fi - if test "x$ac_cv_linux_kernel_posix_lock_file_wait_arg" = "xyes" ; then - AC_DEFINE(POSIX_LOCK_FILE_WAIT_ARG, 1, [define if your linux kernel uses 3 arguments for posix_lock_file]) - fi - if test "x$ac_cv_linux_kernel_sock_create_v" = "xyes" ; then - AC_DEFINE(LINUX_KERNEL_SOCK_CREATE_V, 1, [define if your linux kernel uses 5 arguments for sock_create]) - fi - if test "x$ac_cv_linux_get_sb_has_struct_vfsmount" = "xyes"; then - AC_DEFINE(GET_SB_HAS_STRUCT_VFSMOUNT, 1, [define if your get_sb_nodev needs a struct vfsmount argument]) - fi - if test "x$ac_cv_linux_statfs_takes_dentry" = "xyes"; then - AC_DEFINE(STATFS_TAKES_DENTRY, 1, [define if your statfs takes a dentry argument]) - fi - if test "x$ac_cv_linux_func_a_writepage_takes_writeback_control" = "xyes" ; then - AC_DEFINE(AOP_WRITEPAGE_TAKES_WRITEBACK_CONTROL, 1, [define if your aops.writepage takes a struct writeback_control argument]) - fi - if test "x$ac_cv_linux_func_i_create_takes_nameidata" = "xyes" ; then - AC_DEFINE(IOP_CREATE_TAKES_NAMEIDATA, 1, [define if your iops.create takes a nameidata argument]) - fi - if test "x$ac_cv_linux_func_f_flush_takes_fl_owner_t" = "xyes" ; then - AC_DEFINE(FOP_FLUSH_TAKES_FL_OWNER_T, 1, [define if your fops.flush takes an fl_owner_t argument]) - fi - if test "x$ac_cv_linux_func_i_lookup_takes_nameidata" = "xyes" ; then - AC_DEFINE(IOP_LOOKUP_TAKES_NAMEIDATA, 1, [define if your iops.lookup takes a nameidata argument]) - fi - if test "x$ac_cv_linux_func_i_permission_takes_nameidata" = "xyes" ; then - AC_DEFINE(IOP_PERMISSION_TAKES_NAMEIDATA, 1, [define if your iops.permission takes a nameidata argument]) - fi - if test "x$ac_cv_linux_func_d_revalidate_takes_nameidata" = "xyes" ; then - AC_DEFINE(DOP_REVALIDATE_TAKES_NAMEIDATA, 1, [define if your dops.d_revalidate takes a nameidata argument]) - fi - if test "x$ac_cv_linux_init_work_has_data" = "xyes" ; then - AC_DEFINE(INIT_WORK_HAS_DATA, 1, [define if INIT_WORK takes a data (3rd) argument]) - fi - if test "x$ac_cv_linux_register_sysctl_table_noflag" = "xyes" ; then - AC_DEFINE(REGISTER_SYSCTL_TABLE_NOFLAG, 1, [define if register_sysctl_table has no insert_at head flag]) - fi - if test "x$ac_cv_linux_sysctl_table_checking" = "xyes" ; then - AC_DEFINE(SYSCTL_TABLE_CHECKING, 1, [define if your kernel has sysctl table checking]) - fi - if test "x$ac_cv_linux_exports_init_mm" = "xyes" ; then - AC_DEFINE(EXPORTED_INIT_MM, 1, [define if your kernel exports init_mm]) - fi - if test "x$ac_cv_linux_exports_tasklist_lock" = "xyes" ; then - AC_DEFINE(EXPORTED_TASKLIST_LOCK, 1, [define if tasklist_lock exported]) - fi - if test "x$ac_cv_linux_have_kmem_cache_t" = "xyes" ; then - AC_DEFINE(HAVE_KMEM_CACHE_T, 1, [define if kmem_cache_t exists]) - fi - if test "x$ac_cv_linux_kmem_cache_init" = "xyes" ; then - AC_DEFINE(KMEM_CACHE_INIT, 1, [define for new kmem_cache init function parameters]) - fi - if test "x$ac_cv_linux_have_kmem_cache_t" = "xyes" ; then - AC_DEFINE(KMEM_CACHE_TAKES_DTOR, 1, [define if kmem_cache_create takes a destructor argument]) - fi if test "x$ac_cv_linux_kernel_page_follow_link" = "xyes" -o "x$ac_cv_linux_func_i_put_link_takes_cookie" = "xyes"; then AC_DEFINE(USABLE_KERNEL_PAGE_SYMLINK_CACHE, 1, [define if your kernel has a usable symlink cache API]) else AC_MSG_WARN([your kernel does not have a usable symlink cache API]) fi - if test "x$ac_cv_linux_have_svc_addr_in" = "xyes"; then - AC_DEFINE(HAVE_SVC_ADDR_IN, 1, [define if svc_add_in exists]) - fi : fi esac diff --git a/src/afs/LINUX/osi_nfssrv.c b/src/afs/LINUX/osi_nfssrv.c index f30ea1f..4faec6c 100644 --- a/src/afs/LINUX/osi_nfssrv.c +++ b/src/afs/LINUX/osi_nfssrv.c @@ -109,7 +109,7 @@ svcauth_afs_accept(struct svc_rqst *rqstp, u32 *authp) /* XXX maybe we should fail this with rpc_system_err? */ return SVC_OK; } -#if HAVE_SVC_ADDR_IN +#if HAVE_LINUX_SVC_ADDR_IN addr = svc_addr_in(rqstp); #else addr = &rqstp->rq_addr; diff --git a/src/cf/linux-test1.m4 b/src/cf/linux-test1.m4 index 6545717..fb5e061 100644 --- a/src/cf/linux-test1.m4 +++ b/src/cf/linux-test1.m4 @@ -85,19 +85,25 @@ AC_DEFUN([LINUX_KBUILD_USES_EXTRA_CFLAGS], [ CPPFLAGS="$save_CPPFLAGS" AC_MSG_RESULT($ac_linux_kbuild_requires_extra_cflags)]) +dnl AC_CHECK_LINUX_BUILD([msg], [var], [includes], [code], [define]) +AC_DEFUN([AC_CHECK_LINUX_BUILD], + [AS_VAR_PUSHDEF([ac_linux_build], [$2])dnl + AC_CACHE_CHECK([$1], [ac_linux_build], + [AC_TRY_KBUILD([$3], [$4], + AS_VAR_SET([ac_linux_build], [yes]), + AS_VAR_SET([ac_linux_build], [no])) + ]) + AS_IF([test AS_VAR_GET([ac_linux_build]) = yes], + [AC_DEFINE([$5],1,[$6])]) + ]) + dnl AC_CHECK_LINUX_HEADER(header) AC_DEFUN([AC_CHECK_LINUX_HEADER], - [AS_VAR_PUSHDEF([ac_linux_header], [ac_cv_linux_header_$1])dnl - AC_CACHE_CHECK([for linux/$1], [ac_linux_header], - [AC_TRY_KBUILD([#include ], - [return;], - AS_VAR_SET([ac_linux_header], [yes]), - AS_VAR_SET([ac_linux_header], [no])) - ]) - AS_IF([test AS_VAR_GET([ac_linux_header]) = yes], - [AC_DEFINE(AS_TR_CPP(HAVE_LINUX_$1), - 1, - [Define if your kernel has linux/$1])]) + [AC_CHECK_LINUX_BUILD([for linux/$1], [ac_cv_linux_header_$1], + [#include ], + [return;], + AS_TR_CPP(HAVE_LINUX_$1), + [Define if your kernel has linux/$1]) ]) dnl AC_CHECK_LINUX_FUNC([function], [includes], [code]) @@ -118,15 +124,11 @@ AC_DEFUN([AC_CHECK_LINUX_FUNC], dnl AC_CHECK_LINUX_STRUCT([structure], [element], [includes]) AC_DEFUN([AC_CHECK_LINUX_STRUCT], - [AS_VAR_PUSHDEF([ac_linux_struct], [ac_cv_linux_struct_$1_has_$2])dnl - AC_CACHE_CHECK([for $2 in struct $1], [ac_linux_struct], - [AC_TRY_KBUILD([#include ], - [struct $1 _test; printk("%x\n", &_test.$2); ], - AS_VAR_SET([ac_linux_struct], [yes]), - AS_VAR_SET([ac_linux_struct], [no])) - ]) - AS_IF([test AS_VAR_GET([ac_linux_struct]) = yes], - [AC_DEFINE(AS_TR_CPP(STRUCT_$1_HAS_$2), 1, - [Define if kernel struct $1 has the $2 element])]) + [AC_CHECK_LINUX_BUILD([for $2 in struct $1], + [ac_cv_linux_struct_$1_has_$2], + [#include ], + [struct $1 _test; printk("%x\n", &_test.$2); ], + AS_TR_CPP(STRUCT_$1_HAS_$2), + [Define if kernel struct $1 has the $2 element]) ]) diff --git a/src/cf/linux-test4.m4 b/src/cf/linux-test4.m4 index 5595285..4389fd0 100644 --- a/src/cf/linux-test4.m4 +++ b/src/cf/linux-test4.m4 @@ -1,32 +1,26 @@ AC_DEFUN([LINUX_EXPORTS_TASKLIST_LOCK], [ - AC_MSG_CHECKING([for exported tasklist_lock]) - AC_CACHE_VAL([ac_cv_linux_exports_tasklist_lock], [ - AC_TRY_KBUILD( -[ -#include ], + AC_CHECK_LINUX_BUILD([for exported tasklist_lock], + [ac_cv_linux_exports_tasklist_lock], +[#include ], [ extern rwlock_t tasklist_lock __attribute__((weak)); read_lock(&tasklist_lock); ], - ac_cv_linux_exports_tasklist_lock=yes, - ac_cv_linux_exports_tasklist_lock=no)]) - AC_MSG_RESULT($ac_cv_linux_exports_tasklist_lock)]) - + [EXPORTED_TASKLIST_LOCK], + [define if tasklist_lock exported]) +]) AC_DEFUN([LINUX_COMPLETION_H_EXISTS], [ - AC_CACHE_CHECK([for linux/completion.h], [ac_cv_linux_completion_h_exists], - [AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([for linux/completion.h], + [ac_cv_linux_completion_h_exists], [#include #include ], [struct completion _c; #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,4,8) lose #endif], - ac_cv_linux_completion_h_exists=yes, - ac_cv_linux_completion_h_exists=no)]) - AS_IF([test "x$ac_linux_completion_h_exists" = xyes], - [AC_DEFINE(HAVE_LINUX_COMPLETION_H, 1, - [Define if your kernel has a usable linux/completion.h])]) + [HAVE_LINUX_COMPLETION_H] + [Define if your kernel has a usable linux/completion.h]) ]) AC_DEFUN([LINUX_DEFINES_FOR_EACH_PROCESS], [ @@ -56,156 +50,139 @@ AC_DEFUN([LINUX_DEFINES_PREV_TASK], [ AC_DEFUN([LINUX_EXPORTS_INIT_MM], [ - AC_MSG_CHECKING([for exported init_mm]) - AC_CACHE_VAL([ac_cv_linux_exports_init_mm], [ - AC_TRY_KBUILD( -[extern struct mm_struct init_mm;], -[void *address = &init_mm; -printk("%p\n", address);], - ac_cv_linux_exports_init_mm=yes, - ac_cv_linux_exports_init_mm=no)]) - AC_MSG_RESULT($ac_cv_linux_exports_init_mm)]) + AC_CHECK_LINUX_BUILD([for exported init_mm], + [ac_cv_linux_exports_init_mm], + [extern struct mm_struct init_mm;], + [void *address = &init_mm; printk("%p\n", address);], + [EXPORTED_INIT_MM], + [define if your kernel exports init_mm]) + ]) AC_DEFUN([LINUX_EXPORTS_KALLSYMS_ADDRESS], [ - AC_MSG_CHECKING([for exported kallsyms_address_to_symbol]) - AC_CACHE_VAL([ac_cv_linux_exports_kallsyms_address], [ - AC_TRY_KBUILD( -[#include ], + AC_CHECK_LINUX_BUILD([for exported kallsyms_address_to_symbol], + [ac_cv_linux_exports_kallsyms_address], + [#include ], [#ifndef __ver_kallsyms_address_to_symbol #error kallsyms_address_to_symbol not exported #endif], - ac_cv_linux_exports_kallsyms_address=yes, - ac_cv_linux_exports_kallsyms_address=no)]) - AC_MSG_RESULT($ac_cv_linux_exports_kallsyms_address)]) + [EXPORTED_KALLSYMS_ADDRESS], + [define if your linux kernel exports kallsyms address]) +]) AC_DEFUN([LINUX_EXPORTS_KALLSYMS_SYMBOL], [ - AC_MSG_CHECKING([for exported kallsyms_symbol_to_address]) - AC_CACHE_VAL([ac_cv_linux_exports_kallsyms_symbol], [ - AC_TRY_KBUILD( -[#include ], + AC_CHECK_LINUX_BUILD([for exported kallsyms_symbol_to_address], + [ac_cv_linux_exports_kallsyms_symbol], + [#include ], [#ifndef __ver_kallsyms_symbol_to_address #error kallsyms_symbol_to_address not exported #endif], - ac_cv_linux_exports_kallsyms_symbol=yes, - ac_cv_linux_exports_kallsyms_symbol=no)]) - AC_MSG_RESULT($ac_cv_linux_exports_kallsyms_symbol)]) + [EXPORTED_KALLSYMS_SYMBOL], + [define if your linux kernel exports kallsyms]) +]) + AC_DEFUN([LINUX_EXPORTS_SYS_CALL_TABLE], [ - AC_MSG_CHECKING([for exported sys_call_table]) - AC_CACHE_VAL([ac_cv_linux_exports_sys_call_table], [ - AC_TRY_KBUILD( -[#include ], + AC_CHECK_LINUX_BUILD([for exported sys_call_table], + [ac_cv_linux_exports_sys_call_table], + [#include ], [#ifndef __ver_sys_call_table #error sys_call_table not exported #endif], - ac_cv_linux_exports_sys_call_table=yes, - ac_cv_linux_exports_sys_call_table=no)]) - AC_MSG_RESULT($ac_cv_linux_exports_sys_call_table)]) + [EXPORTED_SYS_CALL_TABLE], + [define if your linux kernel exports sys_call_table]) +]) AC_DEFUN([LINUX_EXPORTS_IA32_SYS_CALL_TABLE], [ - AC_MSG_CHECKING([for exported ia32_sys_call_table]) - AC_CACHE_VAL([ac_cv_linux_exports_ia32_sys_call_table], [ - AC_TRY_KBUILD( -[#include ], + AC_CHECK_LINUX_BUILD([for exported ia32_sys_call_table], + [ac_cv_linux_exports_ia32_sys_call_table], + [#include ], [#ifndef __ver_ia32_sys_call_table #error ia32_sys_call_table not exported #endif], - ac_cv_linux_exports_ia32_sys_call_table=yes, - ac_cv_linux_exports_ia32_sys_call_table=no)]) - AC_MSG_RESULT($ac_cv_linux_exports_ia32_sys_call_table)]) + [EXPORTED_IA32_SYS_CALL_TABLE], + [define if your linux kernel exports ia32_sys_call_table]) +]) AC_DEFUN([LINUX_EXPORTS_SYS_CHDIR], [ - AC_MSG_CHECKING([for exported sys_chdir]) - AC_CACHE_VAL([ac_cv_linux_exports_sys_chdir], [ - AC_TRY_KBUILD( -[extern asmlinkage long sys_chdir(void) __attribute__((weak));], -[void *address = &sys_chdir; -printk("%p\n", address);], - ac_cv_linux_exports_sys_chdir=yes, - ac_cv_linux_exports_sys_chdir=no)]) - AC_MSG_RESULT($ac_cv_linux_exports_sys_chdir)]) + AC_CHECK_LINUX_BUILD([for exported sys_chdir], + [ac_cv_linux_exports_sys_chdir], + [extern asmlinkage long sys_chdir(void) __attribute__((weak));], + [void *address = &sys_chdir; printk("%p\n", address);], + [EXPORTED_SYS_CHDIR], + [define if your linux kernel exports sys_chdir]) +]) + AC_DEFUN([LINUX_EXPORTS_SYS_OPEN], [ - AC_MSG_CHECKING([for exported sys_open]) - AC_CACHE_VAL([ac_cv_linux_exports_sys_open], [ - AC_TRY_KBUILD( -[extern asmlinkage long sys_open(void) __attribute__((weak));], -[void *address = &sys_open; -printk("%p\n", address);], - ac_cv_linux_exports_sys_open=yes, - ac_cv_linux_exports_sys_open=no)]) - AC_MSG_RESULT($ac_cv_linux_exports_sys_open)]) + AC_CHECK_LINUX_BUILD([for exported sys_open], + [ac_cv_linux_exports_sys_open], + [extern asmlinkage long sys_open(void) __attribute__((weak));], + [void *address = &sys_open; printk("%p\n", address);], + [EXPORTED_SYS_OPEN], + [define if your linux kernel exports sys_open]) +]) AC_DEFUN([LINUX_RECALC_SIGPENDING_ARG_TYPE], [ - AC_MSG_CHECKING([for recalc_sigpending arg type]) - AC_CACHE_VAL([ac_cv_linux_func_recalc_sigpending_takes_void], [ - AC_TRY_KBUILD( -[#include ], -[recalc_sigpending();], - ac_cv_linux_func_recalc_sigpending_takes_void=yes, - ac_cv_linux_func_recalc_sigpending_takes_void=no)]) - AC_MSG_RESULT($ac_cv_linux_func_recalc_sigpending_takes_void)]) + AC_CHECK_LINUX_BUILD([for recalc_sigpending arg type], + [ac_cv_linux_func_recalc_sigpending_takes_void], + [#include ], + [recalc_sigpending();], + [RECALC_SIGPENDING_TAKES_VOID], + [define if your recalc_sigpending takes void]) +]) AC_DEFUN([LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_SIGNAL_RLIM], [ - AC_CACHE_CHECK([for signal->rlim in struct task_struct], - [ac_cv_linux_sched_struct_task_struct_has_signal_rlim], - [AC_TRY_KBUILD( -[#include ], -[struct task_struct _tsk; -printk("%d\n", _tsk.signal->rlim);], - ac_cv_linux_struct_task_struct_has_signal_rlim=yes, - ac_cv_linux_struct_task_struct_has_signal_rlim=no)]) - AS_IF([test "x$ac_cv_linux_struct_task_struct_has_signal_rlim" = "xyes"], - [AC_DEFINE(STRUCT_TASK_STRUCT_HAS_SIGNAL_RLIM, 1, - [define if your struct task_struct has signal->rlim])]) - ]) + AC_CHECK_LINUX_BUILD([for signal->rlim in struct task_struct], + [ac_cv_linux_sched_struct_task_struct_has_signal_rlim], + [#include ], + [struct task_struct _tsk; printk("%d\n", _tsk.signal->rlim);], + [STRUCT_TASK_STRUCT_HAS_SIGNAL_RLIM], + [define if your struct task_struct has signal->rlim]) +]) AC_DEFUN([LINUX_KERNEL_POSIX_LOCK_FILE_WAIT_ARG], [ - AC_MSG_CHECKING([for 3rd argument in posix_lock_file found in new kernels]) - AC_CACHE_VAL([ac_cv_linux_kernel_posix_lock_file_wait_arg], [ - AC_TRY_KBUILD( -[#include ], -[posix_lock_file(0,0,0);], - ac_cv_linux_kernel_posix_lock_file_wait_arg=yes, - ac_cv_linux_kernel_posix_lock_file_wait_arg=no)]) - AC_MSG_RESULT($ac_cv_linux_kernel_posix_lock_file_wait_arg)]) + AC_CHECK_LINUX_BUILD([for 3rd argument in posix_lock_file found in new kernels], + [ac_cv_linux_kernel_posix_lock_file_wait_arg], + [#include ], + [posix_lock_file(0,0,0);], + [POSIX_LOCK_FILE_WAIT_ARG], + [define if your kernel uses 3 arguments for posix_lock_file]) +]) AC_DEFUN([LINUX_KERNEL_SOCK_CREATE], [ - AC_MSG_CHECKING([for 5th argument in sock_create found in some SELinux kernels]) - AC_CACHE_VAL([ac_cv_linux_kernel_sock_create_v], [ - AC_TRY_KBUILD( -[#include ], -[sock_create(0,0,0,0,0);], - ac_cv_linux_kernel_sock_create_v=yes, - ac_cv_linux_kernel_sock_create_v=no)]) - AC_MSG_RESULT($ac_cv_linux_kernel_sock_create_v)]) + AC_CHECK_LINUX_BUILD([for 5th argument in sock_create found in some SELinux kernels], + [ac_cv_linux_kernel_sock_create_v], + [#include ], + [sock_create(0,0,0,0,0);], + [LINUX_KERNEL_SOCK_CREATE_V], + [define if your linux kernel uses 5 arguments for sock_create]) +]) AC_DEFUN([LINUX_INODE_SETATTR_RETURN_TYPE], [ - AC_MSG_CHECKING([for inode_setattr return type]) - AC_CACHE_VAL([ac_cv_linux_func_inode_setattr_returns_int], [ - AC_TRY_KBUILD( -[#include ], -[struct inode _inode; -struct iattr _iattr; -int i; -i = inode_setattr(&_inode, &_iattr);], - ac_cv_linux_func_inode_setattr_returns_int=yes, - ac_cv_linux_func_inode_setattr_returns_int=no)]) - AC_MSG_RESULT($ac_cv_linux_func_inode_setattr_returns_int)]) + AC_CHECK_LINUX_BUILD([for inode_setattr return type], + [ac_cv_linux_func_inode_setattr_returns_int], + [#include ], + [struct inode _inode; + struct iattr _iattr; + int i; + i = inode_setattr(&_inode, &_iattr);], + [INODE_SETATTR_NOT_VOID], + [define if your setattr return return non-void]) +]) + AC_DEFUN([LINUX_AOP_WRITEBACK_CONTROL], [ - AC_MSG_CHECKING([whether address_space_operations.writepage takes a writeback_control]) - AC_CACHE_VAL([ac_cv_linux_func_a_writepage_takes_writeback_control], [ - AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([whether aop.writepage takes a writeback_control], + [ac_cv_linux_func_a_writepage_takes_writeback_control], [#include #include #include ], @@ -213,76 +190,70 @@ AC_DEFUN([LINUX_AOP_WRITEBACK_CONTROL], [ struct page _page; struct writeback_control _writeback_control; (void)_aops.writepage(&_page, &_writeback_control);], - ac_cv_linux_func_a_writepage_takes_writeback_control=yes, - ac_cv_linux_func_a_writepage_takes_writeback_control=no)]) - AC_MSG_RESULT($ac_cv_linux_func_a_writepage_takes_writeback_control)]) + [AOP_WRITEPAGE_TAKES_WRITEBACK_CONTROL], + [define if aops.writepage takes a struct writeback_control]) +]) AC_DEFUN([LINUX_REFRIGERATOR], [ - AC_MSG_CHECKING([whether refrigerator takes PF_FREEZE]) - AC_CACHE_VAL([ac_cv_linux_func_refrigerator_takes_pf_freeze], [ - AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([whether refrigerator takes PF_FREEZE], + [ac_cv_linux_func_refrigerator_takes_pf_freeze], [#include #ifdef HAVE_LINUX_FREEZER_H #include #endif], -[refrigerator(PF_FREEZE);], - ac_cv_linux_func_refrigerator_takes_pf_freeze=yes, - ac_cv_linux_func_refrigerator_takes_pf_freeze=no)]) - AC_MSG_RESULT($ac_cv_linux_func_refrigerator_takes_pf_freeze) - if test "x$ac_cv_linux_func_refrigerator_takes_pf_freeze" = "xyes"; then - AC_DEFINE([LINUX_REFRIGERATOR_TAKES_PF_FREEZE], 1, [define if your refrigerator takes PF_FREEZE]) - fi]) + [refrigerator(PF_FREEZE);], + [LINUX_REFRIGERATOR_TAKES_PF_FREEZE], + [define if your refrigerator takes PF_FREEZE]) +]) + AC_DEFUN([LINUX_IOP_I_CREATE_TAKES_NAMEIDATA], [ - AC_MSG_CHECKING([whether inode_operations.create takes a nameidata]) - AC_CACHE_VAL([ac_cv_linux_func_i_create_takes_nameidata], [ - AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([whether inode_operations.create takes a nameidata], + [ac_cv_linux_func_i_create_takes_nameidata], [#include #include ], [struct inode _inode; struct dentry _dentry; struct nameidata _nameidata; (void)_inode.i_op->create(&_inode, &_dentry, 0, &_nameidata);], - ac_cv_linux_func_i_create_takes_nameidata=yes, - ac_cv_linux_func_i_create_takes_nameidata=no)]) - AC_MSG_RESULT($ac_cv_linux_func_i_create_takes_nameidata)]) + + [IOP_CREATE_TAKES_NAMEIDATA], + [define if your iops.create takes a nameidata argument]) +]) AC_DEFUN([LINUX_IOP_I_LOOKUP_TAKES_NAMEIDATA], [ - AC_MSG_CHECKING([whether inode_operations.lookup takes a nameidata]) - AC_CACHE_VAL([ac_cv_linux_func_i_lookup_takes_nameidata], [ - AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([whether inode_operations.lookup takes a nameidata], + [ac_cv_linux_func_i_lookup_takes_nameidata], [#include #include ], [struct inode _inode; struct dentry _dentry; struct nameidata _nameidata; (void)_inode.i_op->lookup(&_inode, &_dentry, &_nameidata);], - ac_cv_linux_func_i_lookup_takes_nameidata=yes, - ac_cv_linux_func_i_lookup_takes_nameidata=no)]) - AC_MSG_RESULT($ac_cv_linux_func_i_lookup_takes_nameidata)]) + [IOP_LOOKUP_TAKES_NAMEIDATA], + [define if your iops.lookup takes a nameidata argument]) +]) AC_DEFUN([LINUX_IOP_I_PERMISSION_TAKES_NAMEIDATA], [ - AC_MSG_CHECKING([whether inode_operations.permission takes a nameidata]) - AC_CACHE_VAL([ac_cv_linux_func_i_permission_takes_nameidata], [ - AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([whether inode_operations.permission takes a nameidata], + [ac_cv_linux_func_i_permission_takes_nameidata], [#include #include ], [struct inode _inode; struct dentry _dentry; struct nameidata _nameidata; (void)_inode.i_op->permission(&_inode, 0, &_nameidata);], - ac_cv_linux_func_i_permission_takes_nameidata=yes, - ac_cv_linux_func_i_permission_takes_nameidata=no)]) - AC_MSG_RESULT($ac_cv_linux_func_i_permission_takes_nameidata)]) + [IOP_PERMISSION_TAKES_NAMEIDATA], + [define if your iops.permission takes a nameidata argument]) +]) AC_DEFUN([LINUX_IOP_I_PUT_LINK_TAKES_COOKIE], [ - AC_MSG_CHECKING([whether inode_operations.put_link takes an opaque cookie]) - AC_CACHE_VAL([ac_cv_linux_func_i_put_link_takes_cookie], [ - AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([whether inode_operations.put_link takes an opaque cookie], + [ac_cv_linux_func_i_put_link_takes_cookie], [#include #include ], [struct inode _inode; @@ -290,52 +261,48 @@ struct dentry _dentry; struct nameidata _nameidata; void *cookie; (void)_inode.i_op->put_link(&_dentry, &_nameidata, cookie);], - ac_cv_linux_func_i_put_link_takes_cookie=yes, - ac_cv_linux_func_i_put_link_takes_cookie=no)]) - AC_MSG_RESULT($ac_cv_linux_func_i_put_link_takes_cookie)]) + [IOP_PUT_LINK_TAKES_COOKIE], + [define if your iops.put_link takes a cookie]) +]) AC_DEFUN([LINUX_DOP_D_REVALIDATE_TAKES_NAMEIDATA], [ - AC_MSG_CHECKING([whether dentry_operations.d_revalidate takes a nameidata]) - AC_CACHE_VAL([ac_cv_linux_func_d_revalidate_takes_nameidata], [ - AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([whether dentry_operations.d_revalidate takes a nameidata], + [ac_cv_linux_func_d_revalidate_takes_nameidata], [#include #include ], [struct dentry _dentry; struct nameidata _nameidata; (void)_dentry.d_op->d_revalidate(&_dentry, &_nameidata);], - ac_cv_linux_func_d_revalidate_takes_nameidata=yes, - ac_cv_linux_func_d_revalidate_takes_nameidata=no)]) - AC_MSG_RESULT($ac_cv_linux_func_d_revalidate_takes_nameidata)]) + [DOP_REVALIDATE_TAKES_NAMEIDATA], + [define if your dops.d_revalidate takes a nameidata argument]) +]) + AC_DEFUN([LINUX_GET_SB_HAS_STRUCT_VFSMOUNT], [ - AC_MSG_CHECKING([for struct vfsmount * in get_sb_nodev()]) - AC_CACHE_VAL([ac_cv_linux_get_sb_has_struct_vfsmount], [ - AC_TRY_KBUILD( -[#include ], -[get_sb_nodev(0,0,0,0,0);], - ac_cv_linux_get_sb_has_struct_vfsmount=yes, - ac_cv_linux_get_sb_has_struct_vfsmount=no)]) - AC_MSG_RESULT($ac_cv_linux_get_sb_has_struct_vfsmount)]) + AC_CHECK_LINUX_BUILD([for struct vfsmount * in get_sb_nodev()], + [ac_cv_linux_get_sb_has_struct_vfsmount], + [#include ], + [get_sb_nodev(0,0,0,0,0);], + [GET_SB_HAS_STRUCT_VFSMOUNT], + [define if your get_sb_nodev needs a struct vfsmount argument]) +]) + AC_DEFUN([LINUX_STATFS_TAKES_DENTRY], [ - AC_MSG_CHECKING([for dentry in statfs]) - AC_CACHE_VAL([ac_cv_linux_statfs_takes_dentry], [ - AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([for dentry in statfs], + [ac_cv_linux_statfs_takes_dentry], [#include #include ], -[ -extern int vfs_statfs(struct dentry *, struct kstatfs *); -], - ac_cv_linux_statfs_takes_dentry=yes, - ac_cv_linux_statfs_takes_dentry=no)]) - AC_MSG_RESULT($ac_cv_linux_statfs_takes_dentry)]) + [extern int vfs_statfs(struct dentry *, struct kstatfs *);], + [STATFS_TAKES_DENTRY], + [define if your statfs takes a dentry argument]) +]) AC_DEFUN([LINUX_LINUX_KEYRING_SUPPORT], [ - AC_MSG_CHECKING([for linux kernel keyring support]) - AC_CACHE_VAL([ac_cv_linux_keyring_support], [ - AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([for linux kernel keyring support], + [ac_cv_linux_keyring_support], [#include #ifdef HAVE_LINUX_KEY_TYPE_H #include @@ -350,16 +317,15 @@ request_key(NULL, NULL, NULL); #else #error rebuild your kernel with CONFIG_KEYS #endif], - ac_cv_linux_keyring_support=yes, - ac_cv_linux_keyring_support=no)]) - AC_MSG_RESULT($ac_cv_linux_keyring_support) - if test "x$ac_cv_linux_keyring_support" = "xyes"; then - AC_DEFINE([LINUX_KEYRING_SUPPORT], 1, [define if your kernel has keyring support]) - fi]) + [LINUX_KEYRING_SUPPORT], + [define if your kernel has keyring support]) +]) + AC_DEFUN([LINUX_KEY_ALLOC_NEEDS_STRUCT_TASK], [ - AC_MSG_CHECKING([if key_alloc() takes a struct task *]) - AC_CACHE_VAL([ac_cv_key_alloc_needs_struct_task], [ + AC_CACHE_CHECK([if key_alloc() takes a struct task *], + [ac_cv_key_alloc_needs_struct_task], +[ save_CPPFLAGS="$CPPFLAGS" CPPFLAGS="$CPPFLAGS -Werror -Wno-pointer-arith" AC_TRY_KBUILD( @@ -371,34 +337,35 @@ AC_DEFUN([LINUX_KEY_ALLOC_NEEDS_STRUCT_TASK], [ ac_cv_key_alloc_needs_struct_task=yes, ac_cv_key_alloc_needs_struct_task=no) CPPFLAGS="$save_CPPFLAGS"]) - AC_MSG_RESULT($ac_cv_key_alloc_needs_struct_task) - if test "x$ac_cv_key_alloc_needs_struct_task" = "xyes"; then - AC_DEFINE([KEY_ALLOC_NEEDS_STRUCT_TASK], 1, [define if key_alloc takes a struct task *]) - fi]) + AS_IF([test "x$ac_cv_key_alloc_needs_struct_task" = "xyes"], + [AC_DEFINE([KEY_ALLOC_NEEDS_STRUCT_TASK], 1, + [define if key_alloc takes a struct task *])]) +]) + AC_DEFUN([LINUX_KEY_ALLOC_NEEDS_CRED], [ - AC_MSG_CHECKING([if key_alloc() takes credentials]) - AC_CACHE_VAL([ac_cv_key_alloc_needs_cred], [ + AC_CACHE_CHECK([if key_alloc() takes credentials], + [ac_cv_key_alloc_needs_cred], +[ save_CPPFLAGS="$CPPFLAGS" CPPFLAGS="$CPPFLAGS -Werror -Wno-pointer-arith" AC_TRY_KBUILD( [#include -#include -], +#include ], [struct cred *c = NULL; (void) key_alloc(NULL, NULL, 0, 0, c, 0, 0);], ac_cv_key_alloc_needs_cred=yes, ac_cv_key_alloc_needs_cred=no) CPPFLAGS="$save_CPPFLAGS"]) - AC_MSG_RESULT($ac_cv_key_alloc_needs_cred) - if test "x$ac_cv_key_alloc_needs_cred" = "xyes"; then - AC_DEFINE([KEY_ALLOC_NEEDS_CRED], 1, [define if key_alloc takes credentials]) - fi]) + AS_IF([test "x$ac_cv_key_alloc_needs_cred" = "xyes"], + [AC_DEFINE([KEY_ALLOC_NEEDS_CRED], 1, + [define if key_alloc takes credentials])]) +]) + AC_DEFUN([LINUX_INIT_WORK_HAS_DATA], [ - AC_MSG_CHECKING([whether INIT_WORK has a _data argument]) - AC_CACHE_VAL([ac_cv_linux_init_work_has_data], [ - AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([whether INIT_WORK has a _data argument], + [ac_cv_linux_init_work_has_data], [#include #include ], [ @@ -406,232 +373,194 @@ void f(struct work_struct *w) {} struct work_struct *w; int *i; INIT_WORK(w,f,i);], - ac_cv_linux_init_work_has_data=yes, - ac_cv_linux_init_work_has_data=no)]) - AC_MSG_RESULT($ac_cv_linux_init_work_has_data)]) + [INIT_WORK_HAS_DATA], + [define if INIT_WORK takes a data (3rd) argument]) +]) + AC_DEFUN([LINUX_REGISTER_SYSCTL_TABLE_NOFLAG], [ - AC_MSG_CHECKING([whether register_sysctl_table has an insert_at_head flag argument]) - AC_CACHE_VAL([ac_cv_linux_register_sysctl_table_noflag], [ - AC_TRY_KBUILD( -[#include ], -[ctl_table *t; -register_sysctl_table (t);], - ac_cv_linux_register_sysctl_table_noflag=yes, - ac_cv_linux_register_sysctl_table_noflag=no)]) - AC_MSG_RESULT($ac_cv_linux_register_sysctl_table_noflag)]) + AC_CHECK_LINUX_BUILD([whether register_sysctl_table has an insert_at_head argument], + [ac_cv_linux_register_sysctl_table_noflag], + [#include ], + [ctl_table *t; register_sysctl_table (t);], + [REGISTER_SYSCTL_TABLE_NOFLAG], + [define if register_sysctl_table has no insert_at head flag]) +]) + AC_DEFUN([LINUX_FOP_F_FLUSH_TAKES_FL_OWNER_T], [ - AC_MSG_CHECKING([whether file_operations.flush takes a fl_owner_t]) - AC_CACHE_VAL([ac_cv_linux_func_f_flush_takes_fl_owner_t], [ - AC_TRY_KBUILD( -[#include ], + AC_CHECK_LINUX_BUILD([whether file_operations.flush takes a fl_owner_t], + [ac_cv_linux_func_f_flush_takes_fl_owner_t], + [#include ], [struct inode _inode; struct file _file; fl_owner_t id; (void)_inode.i_fop->flush(&_file, &id);], - ac_cv_linux_func_f_flush_takes_fl_owner_t=yes, - ac_cv_linux_func_f_flush_takes_fl_owner_t=no)]) - AC_MSG_RESULT($ac_cv_linux_func_f_flush_takes_fl_owner_t)]) + [FOP_FLUSH_TAKES_FL_OWNER_T], + [define if your fops.flush takes an fl_owner_t argument]) +]) + AC_DEFUN([LINUX_HAVE_KMEM_CACHE_T], [ - AC_MSG_CHECKING([whether kmem_cache_t exists]) - AC_CACHE_VAL([ac_cv_linux_have_kmem_cache_t], [ - AC_TRY_KBUILD( -[#include ], -[kmem_cache_t *k;], - ac_cv_linux_have_kmem_cache_t=yes, - ac_cv_linux_have_kmem_cache_t=no)]) - AC_MSG_RESULT($ac_cv_linux_have_kmem_cache_t)]) + AC_CHECK_LINUX_BUILD([whether kmem_cache_t exists], + [ac_cv_linux_have_kmem_cache_t], + [#include ], + [kmem_cache_t *k;], + [HAVE_KMEM_CACHE_T], + [define if kmem_cache_t exists]) +]) + AC_DEFUN([LINUX_KMEM_CACHE_CREATE_TAKES_DTOR], [ - AC_MSG_CHECKING([whether kmem_cache_create takes a destructor argument]) - AC_CACHE_VAL([ac_cv_linux_kmem_cache_create_takes_dtor], [ - AC_TRY_KBUILD( -[#include ], -[kmem_cache_create(NULL, 0, 0, 0, NULL, NULL);], - ac_cv_linux_kmem_cache_create_takes_dtor=yes, - ac_cv_linux_kmem_cache_create_takes_dtor=no)]) - AC_MSG_RESULT($ac_cv_linux_kmem_cache_create_takes_dtor)]) - -AC_DEFUN([LINUX_KMEM_CACHE_CREATE_CTOR_TAKES_VOID], [ - AC_MSG_CHECKING([whether kmem_cache_create constructor function takes a void pointer argument]) - AC_CACHE_VAL([ac_cv_linux_kmem_cache_create_ctor_takes_void], [ + AC_CHECK_LINUX_BUILD([whether kmem_cache_create takes a destructor argument], + [ac_cv_linux_kmem_cache_create_takes_dtor], + [#include ], + [kmem_cache_create(NULL, 0, 0, 0, NULL, NULL);], + [KMEM_CACHE_TAKES_DTOR], + [define if kmem_cache_create takes a destructor argument]) +]) + + +AC_DEFUN([LINUX_KMEM_CACHE_CREATE_CTOR_TAKES_VOID],[ + AC_CACHE_CHECK([whether kmem_cache_create constructor takes a void pointer], + [ac_cv_linux_kmem_cache_create_ctor_takes_void], [ save_CPPFLAGS="$CPPFLAGS" CPPFLAGS="$CPPFLAGS -Werror" - AC_TRY_KBUILD( -[#include ], -[void _ctor(void *v) { }; -kmem_cache_create(NULL, 0, 0, 0, _ctor);], - ac_cv_linux_kmem_cache_create_ctor_takes_void=yes, - ac_cv_linux_kmem_cache_create_ctor_takes_void=no) + AC_TRY_KBUILD([#include ], + [void _ctor(void *v) { }; kmem_cache_create(NULL, 0, 0, 0, _ctor);], + ac_cv_linux_kmem_cache_create_ctor_takes_void=yes, + ac_cv_linux_kmem_cache_create_ctor_takes_void=no) CPPFLAGS="$save_CPPFLAGS" + ]) + AS_IF([test "x$ac_cv_linux_kmem_cache_create_ctor_takes_void" = "xyes"], + [AC_DEFINE([KMEM_CACHE_CTOR_TAKES_VOID], 1, + [define if kmem_cache_create constructor takes a single void ptr])]) ]) - AC_MSG_RESULT($ac_cv_linux_kmem_cache_create_ctor_takes_void) - if test "x$ac_cv_linux_kmem_cache_create_ctor_takes_void" = "xyes"; then - AC_DEFINE([KMEM_CACHE_CTOR_TAKES_VOID], 1, [define if kmem_cache_create constructor function takes a single void pointer argument]) - fi]) -AC_DEFUN([LINUX_HAVE_SVC_ADDR_IN], [ - AC_MSG_CHECKING([whether svc_addr_in exists]) - AC_CACHE_VAL([ac_cv_linux_have_svc_addr_in], [ - AC_TRY_KBUILD( -[#include ], -[svc_addr_in(NULL);], - ac_cv_linux_have_svc_addr_in=yes, - ac_cv_linux_have_svc_addr_in=no)]) - AC_MSG_RESULT($ac_cv_linux_have_svc_addr_in)]) dnl This function checks not just the existence of the splice functions, dnl but also that the signature matches (they gained an extra argument dnl around 2.6.17) AC_DEFUN([LINUX_FS_STRUCT_FOP_HAS_SPLICE], [ - AC_CACHE_CHECK([for splice_write and splice_read in struct file_operations], - [ac_cv_linux_fs_struct_fop_has_splice], [ - AC_TRY_KBUILD( -[#include ], -[struct file_operations _fop; -_fop.splice_write(NULL, NULL, NULL, 0, 0); -_fop.splice_read(NULL, NULL, NULL, 0, 0);], - ac_cv_linux_fs_struct_fop_has_splice=yes, - ac_cv_linux_fs_struct_fop_has_splice=no)]) - AS_IF([test "x$ac_cv_linux_fs_struct_fop_has_splice" = "xyes"], - [AC_DEFINE(STRUCT_FILE_OPERATIONS_HAS_SPLICE, 1, - [define if struct file_operations has splice functions])]) - ]) + AC_CHECK_LINUX_BUILD([for splice_write and splice_read in struct file_operations], + [ac_cv_linux_fs_struct_fop_has_splice], + [#include ], + [struct file_operations _fop; + _fop.splice_write(NULL, NULL, NULL, 0, 0); + _fop.splice_read(NULL, NULL, NULL, 0, 0);], + [STRUCT_FILE_OPERATIONS_HAS_SPLICE], + [define if struct file_operations has splice functions]) +]) + AC_DEFUN([LINUX_KMEM_CACHE_INIT], [ - AC_MSG_CHECKING([for new kmem_cache init function parameters]) - AC_CACHE_VAL([ac_cv_linux_kmem_cache_init], [ - AC_TRY_KBUILD( -[#include ], -[extern struct kmem_cache *kmem_cache_create(const char *, size_t, size_t, - unsigned long, - void (*)(struct kmem_cache *, void *)); -return;], - ac_cv_linux_kmem_cache_init=yes, - ac_cv_linux_kmem_cache_init=no)]) - AC_MSG_RESULT($ac_cv_linux_kmem_cache_init)]) + AC_CHECK_LINUX_BUILD([for new kmem_cache init function parameters], + [ac_cv_linux_kmem_cache_init], + [#include ], + [extern struct kmem_cache * + kmem_cache_create(const char *, size_t, size_t, + unsigned long, + void (*)(struct kmem_cache *, void *)); + return;], + [KMEM_CACHE_INIT], + [define for new kmem_cache init function parameters]) +]) + AC_DEFUN([LINUX_SYSCTL_TABLE_CHECKING], [ - AC_MSG_CHECKING([for sysctl table checking]) - AC_CACHE_VAL([ac_cv_linux_sysctl_table_checking], [ - AC_TRY_KBUILD( -[#include ], -[ extern int sysctl_check_table(int) __attribute__((weak)); -sysctl_check_table(NULL);], - ac_cv_linux_sysctl_table_checking=no, - ac_cv_linux_sysctl_table_checking=yes)]) -AC_MSG_RESULT($ac_cv_linux_sysctl_table_checking)]) + AC_CHECK_LINUX_BUILD([for sysctl table checking], + [ac_cv_linux_sysctl_table_checking], + [#include ], + [extern int sysctl_check_table(int) __attribute__((weak)); + sysctl_check_table(NULL);], + [SYSCTL_TABLE_CHECKING], + [define if your kernel has sysctl table checking]) +]) + AC_DEFUN([LINUX_EXPORTS_PROC_ROOT_FS], [ - AC_MSG_CHECKING([if proc_root_fs is defined and exported]) - AC_CACHE_VAL([ac_cv_linux_exports_proc_root_fs], [ - AC_TRY_KBUILD( -[#include ], -[struct proc_dir_entry *p = proc_root_fs;], - ac_cv_linux_exports_proc_root_fs=yes, - ac_cv_linux_exports_proc_root_fs=no)]) - AC_MSG_RESULT($ac_cv_linux_exports_proc_root_fs) - if test "x$ac_cv_linux_exports_proc_root_fs" = "xyes"; then - AC_DEFINE([EXPORTED_PROC_ROOT_FS], 1, [define if proc_root_fs is exported]) - fi]) - + AC_CHECK_LINUX_BUILD([if proc_root_fs is defined and exported], + [ac_cv_linux_exports_proc_root_fs], + [#include ], + [struct proc_dir_entry *p = proc_root_fs;], + [EXPORTED_PROC_ROOT_FS], + [define if proc_root_fs is exported]) +]) + + AC_DEFUN([LINUX_D_PATH_TAKES_STRUCT_PATH], [ - AC_MSG_CHECKING([if d_path() takes a struct path argument]) - AC_CACHE_VAL([ac_cv_linux_d_path_takes_struct_path], [ - AC_TRY_KBUILD( -[#include ], -[struct path *p; -d_path(p, NULL, 0);], - ac_cv_linux_d_path_takes_struct_path=yes, - ac_cv_linux_d_path_takes_struct_path=no)]) - AC_MSG_RESULT($ac_cv_linux_d_path_takes_struct_path) - if test "x$ac_cv_linux_d_path_takes_struct_path" = "xyes"; then - AC_DEFINE([D_PATH_TAKES_STRUCT_PATH], 1, [define if d_path() takes a struct path argument]) - fi]) - + AC_CHECK_LINUX_BUILD([if d_path() takes a struct path argument], + [ac_cv_linux_d_path_takes_struct_path], + [#include ], + [struct path *p; d_path(p, NULL, 0);], + [D_PATH_TAKES_STRUCT_PATH], + [define if d_path() takes a struct path argument]) +]) + + AC_DEFUN([LINUX_NEW_EXPORT_OPS], [ - AC_MSG_CHECKING([if kernel uses new export ops]) - AC_CACHE_VAL([ac_cv_linux_new_export_ops], [ - AC_TRY_KBUILD( -[#include ], -[struct export_operations _eops; -_eops.fh_to_parent(NULL, NULL, 0, 0);], - ac_cv_linux_new_export_ops=yes, - ac_cv_linux_new_export_ops=no)]) - AC_MSG_RESULT($ac_cv_linux_new_export_ops) - if test "x$ac_cv_linux_new_export_ops" = "xyes"; then - AC_DEFINE([NEW_EXPORT_OPS], 1, [define if kernel uses new export ops]) - fi]) - + AC_CHECK_LINUX_BUILD([if kernel uses new export ops], + [ac_cv_linux_new_export_ops], + [#include ], + [struct export_operations _eops; + eops.fh_to_parent(NULL, NULL, 0, 0);], + [NEW_EXPORT_OPS], + [define if kernel uses new export ops]) +]) + AC_DEFUN([LINUX_POSIX_TEST_LOCK_RETURNS_CONFLICT], [ - AC_MSG_CHECKING([if posix_test_lock returns a struct file_lock]) - AC_CACHE_VAL([ac_cv_linux_posix_test_lock_returns_conflict], [ - AC_TRY_KBUILD( -[#include ], -[struct file_lock *lock; - struct file * file; -lock = posix_test_lock(file, lock);], - ac_cv_linux_posix_test_lock_returns_conflict=yes, - ac_cv_linux_posix_test_lock_returns_conflict=no)]) - AC_MSG_RESULT($ac_cv_linux_posix_test_lock_returns_conflict) - if test "x$ac_cv_linux_posix_test_lock_returns_conflict" = "xyes"; then - AC_DEFINE([POSIX_TEST_LOCK_RETURNS_CONFLICT], 1, [define if posix_test_lock returns the conflicting lock]) - fi]) + AC_CHECK_LINUX_BUILD([if posix_test_lock returns a struct file_lock], + [ac_cv_linux_posix_test_lock_returns_conflict], + [#include ], + [struct file_lock *lock; + struct file * file; + lock = posix_test_lock(file, lock);], + [POSIX_TEST_LOCK_RETURNS_CONFLICT], + [define if posix_test_lock returns the conflicting lock]) +]) + AC_DEFUN([LINUX_POSIX_TEST_LOCK_CONFLICT_ARG], [ - AC_MSG_CHECKING([if posix_test_lock takes a conflict argument]) - AC_CACHE_VAL([ac_cv_linux_posix_test_lock_conflict_arg], [ - AC_TRY_KBUILD( -[#include ], -[ struct file_lock *lock; - struct file *file; - posix_test_lock(file, lock, lock);], - ac_cv_linux_posix_test_lock_conflict_arg=yes, - ac_cv_lonuc_posix_test_lock_conflict_arg=no)]) - AC_MSG_RESULT($ac_cv_linux_posix_test_lock_conflict_arg) - if test "x$ac_cv_linux_posix_test_lock_conflict_arg" = "xyes"; then - AC_DEFINE([POSIX_TEST_LOCK_CONFLICT_ARG], 1, [define if posix_test_lock takes a conflict argument]) - fi]) + AC_CHECK_LINUX_BUILD([if posix_test_lock takes a conflict argument], + [ac_cv_linux_posix_test_lock_conflict_arg], + [#include ], + [struct file_lock *lock; + struct file *file; + posix_test_lock(file, lock, lock);], + [POSIX_TEST_LOCK_CONFLICT_ARG], + [define if posix_test_lock takes a conflict argument]) +]) + AC_DEFUN([LINUX_EXPORTS_KEY_TYPE_KEYRING], [ - AC_MSG_CHECKING([for exported key_type_keyring]) - AC_CACHE_VAL([ac_cv_linux_exports_key_type_keyring], [ - AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([for exported key_type_keyring], + [ac_cv_linux_exports_key_type_keyring], [ #ifdef HAVE_LINUX_KEY_TYPE_H #include #endif -#include ], -[ -printk("%s", key_type_keyring.name); +#include ], - ac_cv_linux_exports_key_type_keyring=yes, - ac_cv_linux_exports_key_type_keyring=no)]) - AC_MSG_RESULT($ac_cv_linux_exports_key_type_keyring) - if test "x$ac_cv_linux_exports_key_type_keyring" = "xyes"; then - AC_DEFINE([EXPORTED_KEY_TYPE_KEYRING], 1, [define if key_type_keyring is exported]) - fi]) + [printk("%s", key_type_keyring.name);], + [EXPORTED_KEY_TYPE_KEYRING], + [define if key_type_keyring is exported]) +]) + AC_DEFUN([LINUX_KEYS_HAVE_SESSION_TO_PARENT], [ - AC_MSG_CHECKING([for KEYCTL_SESSION_TO_PARENT]) - AC_CACHE_VAL([ac_cv_linux_have_session_to_parent], [ - AC_TRY_KBUILD( -[ #include ], -[ int i = KEYCTL_SESSION_TO_PARENT;], - ac_cv_linux_have_session_to_parent=yes, - ac_cv_linux_have_session_to_parent=no)]) - AC_MSG_RESULT($ac_cv_linux_have_session_to_parent) - if test "x$ac_cv_linux_have_session_to_parent" = "xyes"; then - AC_DEFINE([HAVE_SESSION_TO_PARENT], 1, [define if keyctl has the KEYCTL_SESSION_TO_PARENT function]) - fi]) + AC_CHECK_LINUX_BUILD([for KEYCTL_SESSION_TO_PARENT], + [ac_cv_linux_have_session_to_parent], + [#include ], + [int i = KEYCTL_SESSION_TO_PARENT;], + [HAVE_SESSION_TO_PARENT], + [define if keyctl has the KEYCTL_SESSION_TO_PARENT function]) +]) + AC_DEFUN([LINUX_HAVE_TRY_TO_FREEZE], [ - AC_MSG_CHECKING([for try_to_freeze]) - AC_CACHE_CHECK([for try_to_freeze], [ac_cv_linux_have_try_to_freeze], - [AC_TRY_KBUILD( + AC_CHECK_LINUX_BUILD([for try_to_freeze], + [ac_cv_linux_have_try_to_freeze], [#include #ifdef HAVE_LINUX_FREEZER_H #include @@ -640,12 +569,8 @@ AC_DEFUN([LINUX_HAVE_TRY_TO_FREEZE], [ try_to_freeze(PF_FREEZE); #else try_to_freeze(); -#endif -], - ac_cv_linux_have_try_to_freeze=yes, - ac_cv_linux_have_try_to_freeze=no)]) - AS_IF([test "x$ac_cv_linux_have_try_to_freeze" = "xyes"], - [AC_DEFINE([HAVE_TRY_TO_FREEZE], 1, - [define if your kernel has the try_to_freeze function])]) - ]) +#endif], + [HAVE_TRY_TO_FREEZE], + [define if your kernel has the try_to_freeze function]) +]) -- 1.9.4