src/cf/linux-test4.m4

   1 AC_DEFUN([LINUX_EXPORTS_TASKLIST_LOCK], [
   2   AC_MSG_CHECKING([for exported tasklist_lock])
   3   AC_CACHE_VAL([ac_cv_linux_exports_tasklist_lock], [
   4     AC_TRY_KBUILD(
   5 [
   6 #include <linux/sched.h>],
   7 [
   8 extern rwlock_t tasklist_lock __attribute__((weak));
   9 read_lock(&tasklist_lock);
  10 ],
  11       ac_cv_linux_exports_tasklist_lock=yes,
  12       ac_cv_linux_exports_tasklist_lock=no)])
  13   AC_MSG_RESULT($ac_cv_linux_exports_tasklist_lock)])
  14
  15
  16 AC_DEFUN([LINUX_COMPLETION_H_EXISTS], [
  17   AC_CACHE_CHECK([for linux/completion.h], [ac_cv_linux_completion_h_exists],
  18    [AC_TRY_KBUILD(
  19 [#include <linux/version.h>
  20 #include <linux/completion.h>],
  21 [struct completion _c;
  22 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,4,8)
  23 lose
  24 #endif],
  25       ac_cv_linux_completion_h_exists=yes,
  26       ac_cv_linux_completion_h_exists=no)])
  27   AS_IF([test "x$ac_linux_completion_h_exists" = xyes],
  28         [AC_DEFINE(HAVE_LINUX_COMPLETION_H, 1,
  29                    [Define if your kernel has a usable linux/completion.h])])
  30 ])
  31
  32 AC_DEFUN([LINUX_DEFINES_FOR_EACH_PROCESS], [
  33   AC_MSG_CHECKING([for defined for_each_process])
  34   AC_CACHE_VAL([ac_cv_linux_defines_for_each_process], [
  35     AC_TRY_KBUILD(
  36 [#include <linux/sched.h>],
  37 [#ifndef for_each_process
  38 #error for_each_process not defined
  39 #endif],
  40       ac_cv_linux_defines_for_each_process=yes,
  41       ac_cv_linux_defines_for_each_process=no)])
  42   AC_MSG_RESULT($ac_cv_linux_defines_for_each_process)])
  43
  44
  45 AC_DEFUN([LINUX_DEFINES_PREV_TASK], [
  46   AC_MSG_CHECKING([for defined prev_task])
  47   AC_CACHE_VAL([ac_cv_linux_defines_prev_task], [
  48     AC_TRY_KBUILD(
  49 [#include <linux/sched.h>],
  50 [#ifndef prev_task
  51 #error prev_task not defined
  52 #endif],
  53       ac_cv_linux_defines_prev_task=yes,
  54       ac_cv_linux_defines_prev_task=no)])
  55   AC_MSG_RESULT($ac_cv_linux_defines_prev_task)])
  56
  57
  58 AC_DEFUN([LINUX_EXPORTS_INIT_MM], [
  59   AC_MSG_CHECKING([for exported init_mm])
  60   AC_CACHE_VAL([ac_cv_linux_exports_init_mm], [
  61     AC_TRY_KBUILD(
  62 [extern struct mm_struct init_mm;],
  63 [void *address = &init_mm;
  64 printk("%p\n", address);],
  65       ac_cv_linux_exports_init_mm=yes,
  66       ac_cv_linux_exports_init_mm=no)])
  67   AC_MSG_RESULT($ac_cv_linux_exports_init_mm)])
  68
  69
  70 AC_DEFUN([LINUX_EXPORTS_KALLSYMS_ADDRESS], [
  71   AC_MSG_CHECKING([for exported kallsyms_address_to_symbol])
  72   AC_CACHE_VAL([ac_cv_linux_exports_kallsyms_address], [
  73     AC_TRY_KBUILD(
  74 [#include <linux/modversions.h>],
  75 [#ifndef __ver_kallsyms_address_to_symbol
  76 #error kallsyms_address_to_symbol not exported
  77 #endif],
  78       ac_cv_linux_exports_kallsyms_address=yes,
  79       ac_cv_linux_exports_kallsyms_address=no)])
  80   AC_MSG_RESULT($ac_cv_linux_exports_kallsyms_address)])
  81
  82
  83 AC_DEFUN([LINUX_EXPORTS_KALLSYMS_SYMBOL], [
  84   AC_MSG_CHECKING([for exported kallsyms_symbol_to_address])
  85   AC_CACHE_VAL([ac_cv_linux_exports_kallsyms_symbol], [
  86     AC_TRY_KBUILD(
  87 [#include <linux/modversions.h>],
  88 [#ifndef __ver_kallsyms_symbol_to_address
  89 #error kallsyms_symbol_to_address not exported
  90 #endif],
  91       ac_cv_linux_exports_kallsyms_symbol=yes,
  92       ac_cv_linux_exports_kallsyms_symbol=no)])
  93   AC_MSG_RESULT($ac_cv_linux_exports_kallsyms_symbol)])
  94
  95 AC_DEFUN([LINUX_EXPORTS_SYS_CALL_TABLE], [
  96   AC_MSG_CHECKING([for exported sys_call_table])
  97   AC_CACHE_VAL([ac_cv_linux_exports_sys_call_table], [
  98     AC_TRY_KBUILD(
  99 [#include <linux/modversions.h>],
 100 [#ifndef __ver_sys_call_table
 101 #error sys_call_table not exported
 102 #endif],
 103       ac_cv_linux_exports_sys_call_table=yes,
 104       ac_cv_linux_exports_sys_call_table=no)])
 105   AC_MSG_RESULT($ac_cv_linux_exports_sys_call_table)])
 106
 107
 108 AC_DEFUN([LINUX_EXPORTS_IA32_SYS_CALL_TABLE], [
 109   AC_MSG_CHECKING([for exported ia32_sys_call_table])
 110   AC_CACHE_VAL([ac_cv_linux_exports_ia32_sys_call_table], [
 111     AC_TRY_KBUILD(
 112 [#include <linux/modversions.h>],
 113 [#ifndef __ver_ia32_sys_call_table
 114 #error ia32_sys_call_table not exported
 115 #endif],
 116       ac_cv_linux_exports_ia32_sys_call_table=yes,
 117       ac_cv_linux_exports_ia32_sys_call_table=no)])
 118   AC_MSG_RESULT($ac_cv_linux_exports_ia32_sys_call_table)])
 119
 120
 121 AC_DEFUN([LINUX_EXPORTS_SYS_CHDIR], [
 122   AC_MSG_CHECKING([for exported sys_chdir])
 123   AC_CACHE_VAL([ac_cv_linux_exports_sys_chdir], [
 124     AC_TRY_KBUILD(
 125 [extern asmlinkage long sys_chdir(void) __attribute__((weak));],
 126 [void *address = &sys_chdir;
 127 printk("%p\n", address);],
 128       ac_cv_linux_exports_sys_chdir=yes,
 129       ac_cv_linux_exports_sys_chdir=no)])
 130   AC_MSG_RESULT($ac_cv_linux_exports_sys_chdir)])
 131
 132 AC_DEFUN([LINUX_EXPORTS_SYS_OPEN], [
 133   AC_MSG_CHECKING([for exported sys_open])
 134   AC_CACHE_VAL([ac_cv_linux_exports_sys_open], [
 135     AC_TRY_KBUILD(
 136 [extern asmlinkage long sys_open(void) __attribute__((weak));],
 137 [void *address = &sys_open;
 138 printk("%p\n", address);],
 139       ac_cv_linux_exports_sys_open=yes,
 140       ac_cv_linux_exports_sys_open=no)])
 141   AC_MSG_RESULT($ac_cv_linux_exports_sys_open)])
 142
 143
 144 AC_DEFUN([LINUX_RECALC_SIGPENDING_ARG_TYPE], [
 145   AC_MSG_CHECKING([for recalc_sigpending arg type])
 146   AC_CACHE_VAL([ac_cv_linux_func_recalc_sigpending_takes_void], [
 147     AC_TRY_KBUILD(
 148 [#include <linux/sched.h>],
 149 [recalc_sigpending();],
 150       ac_cv_linux_func_recalc_sigpending_takes_void=yes,
 151       ac_cv_linux_func_recalc_sigpending_takes_void=no)])
 152   AC_MSG_RESULT($ac_cv_linux_func_recalc_sigpending_takes_void)])
 153
 154
 155 AC_DEFUN([LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_SIGNAL_RLIM], [
 156   AC_CACHE_CHECK([for signal->rlim in struct task_struct],
 157    [ac_cv_linux_sched_struct_task_struct_has_signal_rlim],
 158    [AC_TRY_KBUILD(
 159 [#include <linux/sched.h>],
 160 [struct task_struct _tsk;
 161 printk("%d\n", _tsk.signal->rlim);],
 162       ac_cv_linux_struct_task_struct_has_signal_rlim=yes,
 163       ac_cv_linux_struct_task_struct_has_signal_rlim=no)])
 164     AS_IF([test "x$ac_cv_linux_struct_task_struct_has_signal_rlim" = "xyes"],
 165           [AC_DEFINE(STRUCT_TASK_STRUCT_HAS_SIGNAL_RLIM, 1,
 166                      [define if your struct task_struct has signal->rlim])])
 167    ])
 168
 169
 170 AC_DEFUN([LINUX_KERNEL_POSIX_LOCK_FILE_WAIT_ARG], [
 171   AC_MSG_CHECKING([for 3rd argument in posix_lock_file found in new kernels])
 172   AC_CACHE_VAL([ac_cv_linux_kernel_posix_lock_file_wait_arg], [
 173     AC_TRY_KBUILD(
 174 [#include <linux/fs.h>],
 175 [posix_lock_file(0,0,0);],
 176       ac_cv_linux_kernel_posix_lock_file_wait_arg=yes,
 177       ac_cv_linux_kernel_posix_lock_file_wait_arg=no)])
 178   AC_MSG_RESULT($ac_cv_linux_kernel_posix_lock_file_wait_arg)])
 179
 180 AC_DEFUN([LINUX_KERNEL_SOCK_CREATE], [
 181   AC_MSG_CHECKING([for 5th argument in sock_create found in some SELinux kernels])
 182   AC_CACHE_VAL([ac_cv_linux_kernel_sock_create_v], [
 183     AC_TRY_KBUILD(
 184 [#include <linux/net.h>],
 185 [sock_create(0,0,0,0,0);],
 186       ac_cv_linux_kernel_sock_create_v=yes,
 187       ac_cv_linux_kernel_sock_create_v=no)])
 188   AC_MSG_RESULT($ac_cv_linux_kernel_sock_create_v)])
 189
 190
 191 AC_DEFUN([LINUX_INODE_SETATTR_RETURN_TYPE], [
 192   AC_MSG_CHECKING([for inode_setattr return type])
 193   AC_CACHE_VAL([ac_cv_linux_func_inode_setattr_returns_int], [
 194     AC_TRY_KBUILD(
 195 [#include <linux/fs.h>],
 196 [struct inode _inode;
 197 struct iattr _iattr;
 198 int i;
 199 i = inode_setattr(&_inode, &_iattr);],
 200       ac_cv_linux_func_inode_setattr_returns_int=yes,
 201       ac_cv_linux_func_inode_setattr_returns_int=no)])
 202   AC_MSG_RESULT($ac_cv_linux_func_inode_setattr_returns_int)])
 203
 204
 205 AC_DEFUN([LINUX_AOP_WRITEBACK_CONTROL], [
 206   AC_MSG_CHECKING([whether address_space_operations.writepage takes a writeback_control])
 207   AC_CACHE_VAL([ac_cv_linux_func_a_writepage_takes_writeback_control], [
 208     AC_TRY_KBUILD(
 209 [#include <linux/fs.h>
 210 #include <linux/mm.h>
 211 #include <linux/writeback.h>],
 212 [struct address_space_operations _aops;
 213 struct page _page;
 214 struct writeback_control _writeback_control;
 215 (void)_aops.writepage(&_page, &_writeback_control);],
 216       ac_cv_linux_func_a_writepage_takes_writeback_control=yes,
 217       ac_cv_linux_func_a_writepage_takes_writeback_control=no)])
 218   AC_MSG_RESULT($ac_cv_linux_func_a_writepage_takes_writeback_control)])
 219
 220
 221 AC_DEFUN([LINUX_REFRIGERATOR], [
 222   AC_MSG_CHECKING([whether refrigerator takes PF_FREEZE])
 223   AC_CACHE_VAL([ac_cv_linux_func_refrigerator_takes_pf_freeze], [
 224     AC_TRY_KBUILD(
 225 [#include <linux/sched.h>
 226 #ifdef HAVE_LINUX_FREEZER_H
 227 #include <linux/freezer.h>
 228 #endif],
 229 [refrigerator(PF_FREEZE);],
 230       ac_cv_linux_func_refrigerator_takes_pf_freeze=yes,
 231       ac_cv_linux_func_refrigerator_takes_pf_freeze=no)])
 232   AC_MSG_RESULT($ac_cv_linux_func_refrigerator_takes_pf_freeze)
 233   if test "x$ac_cv_linux_func_refrigerator_takes_pf_freeze" = "xyes"; then
 234     AC_DEFINE([LINUX_REFRIGERATOR_TAKES_PF_FREEZE], 1, [define if your refrigerator takes PF_FREEZE])
 235   fi])
 236
 237 AC_DEFUN([LINUX_IOP_I_CREATE_TAKES_NAMEIDATA], [
 238   AC_MSG_CHECKING([whether inode_operations.create takes a nameidata])
 239   AC_CACHE_VAL([ac_cv_linux_func_i_create_takes_nameidata], [
 240     AC_TRY_KBUILD(
 241 [#include <linux/fs.h>
 242 #include <linux/namei.h>],
 243 [struct inode _inode;
 244 struct dentry _dentry;
 245 struct nameidata _nameidata;
 246 (void)_inode.i_op->create(&_inode, &_dentry, 0, &_nameidata);],
 247       ac_cv_linux_func_i_create_takes_nameidata=yes,
 248       ac_cv_linux_func_i_create_takes_nameidata=no)])
 249   AC_MSG_RESULT($ac_cv_linux_func_i_create_takes_nameidata)])
 250
 251
 252 AC_DEFUN([LINUX_IOP_I_LOOKUP_TAKES_NAMEIDATA], [
 253   AC_MSG_CHECKING([whether inode_operations.lookup takes a nameidata])
 254   AC_CACHE_VAL([ac_cv_linux_func_i_lookup_takes_nameidata], [
 255     AC_TRY_KBUILD(
 256 [#include <linux/fs.h>
 257 #include <linux/namei.h>],
 258 [struct inode _inode;
 259 struct dentry _dentry;
 260 struct nameidata _nameidata;
 261 (void)_inode.i_op->lookup(&_inode, &_dentry, &_nameidata);],
 262       ac_cv_linux_func_i_lookup_takes_nameidata=yes,
 263       ac_cv_linux_func_i_lookup_takes_nameidata=no)])
 264   AC_MSG_RESULT($ac_cv_linux_func_i_lookup_takes_nameidata)])
 265
 266
 267 AC_DEFUN([LINUX_IOP_I_PERMISSION_TAKES_NAMEIDATA], [
 268   AC_MSG_CHECKING([whether inode_operations.permission takes a nameidata])
 269   AC_CACHE_VAL([ac_cv_linux_func_i_permission_takes_nameidata], [
 270     AC_TRY_KBUILD(
 271 [#include <linux/fs.h>
 272 #include <linux/namei.h>],
 273 [struct inode _inode;
 274 struct dentry _dentry;
 275 struct nameidata _nameidata;
 276 (void)_inode.i_op->permission(&_inode, 0, &_nameidata);],
 277       ac_cv_linux_func_i_permission_takes_nameidata=yes,
 278       ac_cv_linux_func_i_permission_takes_nameidata=no)])
 279   AC_MSG_RESULT($ac_cv_linux_func_i_permission_takes_nameidata)])
 280
 281
 282 AC_DEFUN([LINUX_IOP_I_PUT_LINK_TAKES_COOKIE], [
 283   AC_MSG_CHECKING([whether inode_operations.put_link takes an opaque cookie])
 284   AC_CACHE_VAL([ac_cv_linux_func_i_put_link_takes_cookie], [
 285     AC_TRY_KBUILD(
 286 [#include <linux/fs.h>
 287 #include <linux/namei.h>],
 288 [struct inode _inode;
 289 struct dentry _dentry;
 290 struct nameidata _nameidata;
 291 void *cookie;
 292 (void)_inode.i_op->put_link(&_dentry, &_nameidata, cookie);],
 293       ac_cv_linux_func_i_put_link_takes_cookie=yes,
 294       ac_cv_linux_func_i_put_link_takes_cookie=no)])
 295   AC_MSG_RESULT($ac_cv_linux_func_i_put_link_takes_cookie)])
 296
 297
 298 AC_DEFUN([LINUX_DOP_D_REVALIDATE_TAKES_NAMEIDATA], [
 299   AC_MSG_CHECKING([whether dentry_operations.d_revalidate takes a nameidata])
 300   AC_CACHE_VAL([ac_cv_linux_func_d_revalidate_takes_nameidata], [
 301     AC_TRY_KBUILD(
 302 [#include <linux/fs.h>
 303 #include <linux/namei.h>],
 304 [struct dentry _dentry;
 305 struct nameidata _nameidata;
 306 (void)_dentry.d_op->d_revalidate(&_dentry, &_nameidata);],
 307       ac_cv_linux_func_d_revalidate_takes_nameidata=yes,
 308       ac_cv_linux_func_d_revalidate_takes_nameidata=no)])
 309   AC_MSG_RESULT($ac_cv_linux_func_d_revalidate_takes_nameidata)])
 310
 311 AC_DEFUN([LINUX_GET_SB_HAS_STRUCT_VFSMOUNT], [
 312   AC_MSG_CHECKING([for struct vfsmount * in get_sb_nodev()])
 313   AC_CACHE_VAL([ac_cv_linux_get_sb_has_struct_vfsmount], [
 314     AC_TRY_KBUILD(
 315 [#include <linux/fs.h>],
 316 [get_sb_nodev(0,0,0,0,0);],
 317       ac_cv_linux_get_sb_has_struct_vfsmount=yes,
 318       ac_cv_linux_get_sb_has_struct_vfsmount=no)])
 319   AC_MSG_RESULT($ac_cv_linux_get_sb_has_struct_vfsmount)])
 320
 321 AC_DEFUN([LINUX_STATFS_TAKES_DENTRY], [
 322   AC_MSG_CHECKING([for dentry in statfs])
 323   AC_CACHE_VAL([ac_cv_linux_statfs_takes_dentry], [
 324     AC_TRY_KBUILD(
 325 [#include <linux/fs.h>
 326 #include <linux/statfs.h>],
 327 [
 328 extern int vfs_statfs(struct dentry *, struct kstatfs *);
 329 ],
 330       ac_cv_linux_statfs_takes_dentry=yes,
 331       ac_cv_linux_statfs_takes_dentry=no)])
 332   AC_MSG_RESULT($ac_cv_linux_statfs_takes_dentry)])
 333
 334
 335 AC_DEFUN([LINUX_LINUX_KEYRING_SUPPORT], [
 336   AC_MSG_CHECKING([for linux kernel keyring support])
 337   AC_CACHE_VAL([ac_cv_linux_keyring_support], [
 338     AC_TRY_KBUILD(
 339 [#include <linux/rwsem.h>
 340 #ifdef HAVE_LINUX_KEY_TYPE_H
 341 #include <linux/key-type.h>
 342 #endif
 343 #include <linux/key.h>
 344 #include <linux/keyctl.h>],
 345 [#ifdef CONFIG_KEYS
 346 request_key(NULL, NULL, NULL);
 347 #if !defined(KEY_POS_VIEW) || !defined(KEY_POS_SEARCH) || !defined(KEY_POS_SETATTR)
 348 #error "Your linux/key.h does not contain KEY_POS_VIEW or KEY_POS_SEARCH or KEY_POS_SETATTR"
 349 #endif
 350 #else
 351 #error rebuild your kernel with CONFIG_KEYS
 352 #endif],
 353       ac_cv_linux_keyring_support=yes,
 354       ac_cv_linux_keyring_support=no)])
 355   AC_MSG_RESULT($ac_cv_linux_keyring_support)
 356   if test "x$ac_cv_linux_keyring_support" = "xyes"; then
 357     AC_DEFINE([LINUX_KEYRING_SUPPORT], 1, [define if your kernel has keyring support])
 358   fi])
 359
 360 AC_DEFUN([LINUX_KEY_ALLOC_NEEDS_STRUCT_TASK], [
 361   AC_MSG_CHECKING([if key_alloc() takes a struct task *])
 362   AC_CACHE_VAL([ac_cv_key_alloc_needs_struct_task], [
 363     save_CPPFLAGS="$CPPFLAGS"
 364     CPPFLAGS="$CPPFLAGS -Werror -Wno-pointer-arith"
 365     AC_TRY_KBUILD(
 366 [#include <linux/rwsem.h>
 367 #include <linux/key.h>
 368 ],
 369 [struct task_struct *t=NULL;
 370 (void) key_alloc(NULL, NULL, 0, 0, t, 0, 0);],
 371       ac_cv_key_alloc_needs_struct_task=yes,
 372       ac_cv_key_alloc_needs_struct_task=no)
 373     CPPFLAGS="$save_CPPFLAGS"])
 374   AC_MSG_RESULT($ac_cv_key_alloc_needs_struct_task)
 375   if test "x$ac_cv_key_alloc_needs_struct_task" = "xyes"; then
 376     AC_DEFINE([KEY_ALLOC_NEEDS_STRUCT_TASK], 1, [define if key_alloc takes a struct task *])
 377   fi])
 378
 379 AC_DEFUN([LINUX_KEY_ALLOC_NEEDS_CRED], [
 380   AC_MSG_CHECKING([if key_alloc() takes credentials])
 381   AC_CACHE_VAL([ac_cv_key_alloc_needs_cred], [
 382     save_CPPFLAGS="$CPPFLAGS"
 383     CPPFLAGS="$CPPFLAGS -Werror -Wno-pointer-arith"
 384     AC_TRY_KBUILD(
 385 [#include <linux/rwsem.h>
 386 #include <linux/key.h>
 387 ],
 388 [struct cred *c = NULL;
 389 (void) key_alloc(NULL, NULL, 0, 0, c, 0, 0);],
 390       ac_cv_key_alloc_needs_cred=yes,
 391       ac_cv_key_alloc_needs_cred=no)
 392     CPPFLAGS="$save_CPPFLAGS"])
 393   AC_MSG_RESULT($ac_cv_key_alloc_needs_cred)
 394   if test "x$ac_cv_key_alloc_needs_cred" = "xyes"; then
 395     AC_DEFINE([KEY_ALLOC_NEEDS_CRED], 1, [define if key_alloc takes credentials])
 396   fi])
 397
 398 AC_DEFUN([LINUX_INIT_WORK_HAS_DATA], [
 399   AC_MSG_CHECKING([whether INIT_WORK has a _data argument])
 400   AC_CACHE_VAL([ac_cv_linux_init_work_has_data], [
 401     AC_TRY_KBUILD(
 402 [#include <linux/kernel.h>
 403 #include <linux/workqueue.h>],
 404 [
 405 void f(struct work_struct *w) {}
 406 struct work_struct *w;
 407 int *i;
 408 INIT_WORK(w,f,i);],
 409       ac_cv_linux_init_work_has_data=yes,
 410       ac_cv_linux_init_work_has_data=no)])
 411   AC_MSG_RESULT($ac_cv_linux_init_work_has_data)])
 412
 413 AC_DEFUN([LINUX_REGISTER_SYSCTL_TABLE_NOFLAG], [
 414   AC_MSG_CHECKING([whether register_sysctl_table has an insert_at_head flag argument])
 415   AC_CACHE_VAL([ac_cv_linux_register_sysctl_table_noflag], [
 416     AC_TRY_KBUILD(
 417 [#include <linux/sysctl.h>],
 418 [ctl_table *t;
 419 register_sysctl_table (t);],
 420       ac_cv_linux_register_sysctl_table_noflag=yes,
 421       ac_cv_linux_register_sysctl_table_noflag=no)])
 422   AC_MSG_RESULT($ac_cv_linux_register_sysctl_table_noflag)])
 423
 424 AC_DEFUN([LINUX_FOP_F_FLUSH_TAKES_FL_OWNER_T], [
 425   AC_MSG_CHECKING([whether file_operations.flush takes a fl_owner_t])
 426   AC_CACHE_VAL([ac_cv_linux_func_f_flush_takes_fl_owner_t], [
 427     AC_TRY_KBUILD(
 428 [#include <linux/fs.h>],
 429 [struct inode _inode;
 430 struct file _file;
 431 fl_owner_t id;
 432 (void)_inode.i_fop->flush(&_file, &id);],
 433       ac_cv_linux_func_f_flush_takes_fl_owner_t=yes,
 434       ac_cv_linux_func_f_flush_takes_fl_owner_t=no)])
 435   AC_MSG_RESULT($ac_cv_linux_func_f_flush_takes_fl_owner_t)])
 436
 437 AC_DEFUN([LINUX_HAVE_KMEM_CACHE_T], [
 438   AC_MSG_CHECKING([whether kmem_cache_t exists])
 439   AC_CACHE_VAL([ac_cv_linux_have_kmem_cache_t], [
 440     AC_TRY_KBUILD(
 441 [#include <linux/slab.h>],
 442 [kmem_cache_t *k;],
 443       ac_cv_linux_have_kmem_cache_t=yes,
 444       ac_cv_linux_have_kmem_cache_t=no)])
 445   AC_MSG_RESULT($ac_cv_linux_have_kmem_cache_t)])
 446
 447 AC_DEFUN([LINUX_KMEM_CACHE_CREATE_TAKES_DTOR], [
 448   AC_MSG_CHECKING([whether kmem_cache_create takes a destructor argument])
 449   AC_CACHE_VAL([ac_cv_linux_kmem_cache_create_takes_dtor], [
 450     AC_TRY_KBUILD(
 451 [#include <linux/slab.h>],
 452 [kmem_cache_create(NULL, 0, 0, 0, NULL, NULL);],
 453       ac_cv_linux_kmem_cache_create_takes_dtor=yes,
 454       ac_cv_linux_kmem_cache_create_takes_dtor=no)])
 455   AC_MSG_RESULT($ac_cv_linux_kmem_cache_create_takes_dtor)])
 456
 457 AC_DEFUN([LINUX_KMEM_CACHE_CREATE_CTOR_TAKES_VOID], [
 458   AC_MSG_CHECKING([whether kmem_cache_create constructor function takes a void pointer argument])
 459   AC_CACHE_VAL([ac_cv_linux_kmem_cache_create_ctor_takes_void], [
 460     save_CPPFLAGS="$CPPFLAGS"
 461     CPPFLAGS="$CPPFLAGS -Werror"
 462     AC_TRY_KBUILD(
 463 [#include <linux/slab.h>],
 464 [void _ctor(void *v) { };
 465 kmem_cache_create(NULL, 0, 0, 0, _ctor);],
 466       ac_cv_linux_kmem_cache_create_ctor_takes_void=yes,
 467       ac_cv_linux_kmem_cache_create_ctor_takes_void=no)
 468     CPPFLAGS="$save_CPPFLAGS"
 469 ])
 470   AC_MSG_RESULT($ac_cv_linux_kmem_cache_create_ctor_takes_void)
 471   if test "x$ac_cv_linux_kmem_cache_create_ctor_takes_void" = "xyes"; then
 472     AC_DEFINE([KMEM_CACHE_CTOR_TAKES_VOID], 1, [define if kmem_cache_create constructor function takes a single void pointer argument])
 473   fi])
 474
 475 AC_DEFUN([LINUX_HAVE_SVC_ADDR_IN], [
 476   AC_MSG_CHECKING([whether svc_addr_in exists])
 477   AC_CACHE_VAL([ac_cv_linux_have_svc_addr_in], [
 478     AC_TRY_KBUILD(
 479 [#include <linux/sunrpc/svc.h>],
 480 [svc_addr_in(NULL);],
 481       ac_cv_linux_have_svc_addr_in=yes,
 482       ac_cv_linux_have_svc_addr_in=no)])
 483   AC_MSG_RESULT($ac_cv_linux_have_svc_addr_in)])
 484
 485 dnl This function checks not just the existence of the splice functions,
 486 dnl but also that the signature matches (they gained an extra argument
 487 dnl around 2.6.17)
 488 AC_DEFUN([LINUX_FS_STRUCT_FOP_HAS_SPLICE], [
 489   AC_CACHE_CHECK([for splice_write and splice_read in struct file_operations],
 490     [ac_cv_linux_fs_struct_fop_has_splice], [
 491     AC_TRY_KBUILD(
 492 [#include <linux/fs.h>],
 493 [struct file_operations _fop;
 494 _fop.splice_write(NULL, NULL, NULL, 0, 0);
 495 _fop.splice_read(NULL, NULL, NULL, 0, 0);],
 496       ac_cv_linux_fs_struct_fop_has_splice=yes,
 497       ac_cv_linux_fs_struct_fop_has_splice=no)])
 498   AS_IF([test "x$ac_cv_linux_fs_struct_fop_has_splice" = "xyes"],
 499         [AC_DEFINE(STRUCT_FILE_OPERATIONS_HAS_SPLICE, 1,
 500                    [define if struct file_operations has splice functions])])
 501   ])
 502
 503 AC_DEFUN([LINUX_KMEM_CACHE_INIT], [
 504   AC_MSG_CHECKING([for new kmem_cache init function parameters])
 505   AC_CACHE_VAL([ac_cv_linux_kmem_cache_init], [
 506     AC_TRY_KBUILD(
 507 [#include <linux/slab.h>],
 508 [extern struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
 509                         unsigned long,
 510                         void (*)(struct kmem_cache *, void *));
 511 return;],
 512       ac_cv_linux_kmem_cache_init=yes,
 513       ac_cv_linux_kmem_cache_init=no)])
 514   AC_MSG_RESULT($ac_cv_linux_kmem_cache_init)])
 515
 516 AC_DEFUN([LINUX_SYSCTL_TABLE_CHECKING], [
 517   AC_MSG_CHECKING([for sysctl table checking])
 518   AC_CACHE_VAL([ac_cv_linux_sysctl_table_checking], [
 519     AC_TRY_KBUILD(
 520 [#include <linux/sysctl.h>],
 521 [ extern int sysctl_check_table(int) __attribute__((weak));
 522 sysctl_check_table(NULL);],
 523  ac_cv_linux_sysctl_table_checking=no,
 524  ac_cv_linux_sysctl_table_checking=yes)])
 525 AC_MSG_RESULT($ac_cv_linux_sysctl_table_checking)])
 526
 527 AC_DEFUN([LINUX_EXPORTS_PROC_ROOT_FS], [
 528   AC_MSG_CHECKING([if proc_root_fs is defined and exported])
 529   AC_CACHE_VAL([ac_cv_linux_exports_proc_root_fs], [
 530     AC_TRY_KBUILD(
 531 [#include <linux/proc_fs.h>],
 532 [struct proc_dir_entry *p = proc_root_fs;],
 533       ac_cv_linux_exports_proc_root_fs=yes,
 534       ac_cv_linux_exports_proc_root_fs=no)])
 535   AC_MSG_RESULT($ac_cv_linux_exports_proc_root_fs)
 536   if test "x$ac_cv_linux_exports_proc_root_fs" = "xyes"; then
 537     AC_DEFINE([EXPORTED_PROC_ROOT_FS], 1, [define if proc_root_fs is exported])
 538   fi])
 539
 540 AC_DEFUN([LINUX_D_PATH_TAKES_STRUCT_PATH], [
 541   AC_MSG_CHECKING([if d_path() takes a struct path argument])
 542   AC_CACHE_VAL([ac_cv_linux_d_path_takes_struct_path], [
 543     AC_TRY_KBUILD(
 544 [#include <linux/dcache.h>],
 545 [struct path *p;
 546 d_path(p, NULL, 0);],
 547       ac_cv_linux_d_path_takes_struct_path=yes,
 548       ac_cv_linux_d_path_takes_struct_path=no)])
 549   AC_MSG_RESULT($ac_cv_linux_d_path_takes_struct_path)
 550   if test "x$ac_cv_linux_d_path_takes_struct_path" = "xyes"; then
 551     AC_DEFINE([D_PATH_TAKES_STRUCT_PATH], 1, [define if d_path() takes a struct path argument])
 552   fi])
 553
 554 AC_DEFUN([LINUX_NEW_EXPORT_OPS], [
 555   AC_MSG_CHECKING([if kernel uses new export ops])
 556   AC_CACHE_VAL([ac_cv_linux_new_export_ops], [
 557     AC_TRY_KBUILD(
 558 [#include <linux/exportfs.h>],
 559 [struct export_operations _eops;
 560 _eops.fh_to_parent(NULL, NULL, 0, 0);],
 561       ac_cv_linux_new_export_ops=yes,
 562       ac_cv_linux_new_export_ops=no)])
 563   AC_MSG_RESULT($ac_cv_linux_new_export_ops)
 564   if test "x$ac_cv_linux_new_export_ops" = "xyes"; then
 565     AC_DEFINE([NEW_EXPORT_OPS], 1, [define if kernel uses new export ops])
 566   fi])
 567
 568
 569 AC_DEFUN([LINUX_POSIX_TEST_LOCK_RETURNS_CONFLICT], [
 570   AC_MSG_CHECKING([if posix_test_lock returns a struct file_lock])
 571   AC_CACHE_VAL([ac_cv_linux_posix_test_lock_returns_conflict], [
 572     AC_TRY_KBUILD(
 573 [#include <linux/fs.h>],
 574 [struct file_lock *lock;
 575  struct file * file;
 576 lock = posix_test_lock(file, lock);],
 577       ac_cv_linux_posix_test_lock_returns_conflict=yes,
 578       ac_cv_linux_posix_test_lock_returns_conflict=no)])
 579   AC_MSG_RESULT($ac_cv_linux_posix_test_lock_returns_conflict)
 580   if test "x$ac_cv_linux_posix_test_lock_returns_conflict" = "xyes"; then
 581     AC_DEFINE([POSIX_TEST_LOCK_RETURNS_CONFLICT], 1, [define if posix_test_lock returns the conflicting lock])
 582   fi])
 583
 584 AC_DEFUN([LINUX_POSIX_TEST_LOCK_CONFLICT_ARG], [
 585   AC_MSG_CHECKING([if posix_test_lock takes a conflict argument])
 586   AC_CACHE_VAL([ac_cv_linux_posix_test_lock_conflict_arg], [
 587     AC_TRY_KBUILD(
 588 [#include <linux/fs.h>],
 589 [ struct file_lock *lock;
 590   struct file *file;
 591   posix_test_lock(file, lock, lock);],
 592       ac_cv_linux_posix_test_lock_conflict_arg=yes,
 593       ac_cv_lonuc_posix_test_lock_conflict_arg=no)])
 594   AC_MSG_RESULT($ac_cv_linux_posix_test_lock_conflict_arg)
 595   if test "x$ac_cv_linux_posix_test_lock_conflict_arg" = "xyes"; then
 596     AC_DEFINE([POSIX_TEST_LOCK_CONFLICT_ARG], 1, [define if posix_test_lock takes a conflict argument])
 597   fi])
 598
 599 AC_DEFUN([LINUX_EXPORTS_KEY_TYPE_KEYRING], [
 600   AC_MSG_CHECKING([for exported key_type_keyring])
 601   AC_CACHE_VAL([ac_cv_linux_exports_key_type_keyring], [
 602     AC_TRY_KBUILD(
 603 [
 604 #ifdef HAVE_LINUX_KEY_TYPE_H
 605 #include <linux/key-type.h>
 606 #endif
 607 #include <linux/key.h>],
 608 [
 609 printk("%s", key_type_keyring.name);
 610 ],
 611       ac_cv_linux_exports_key_type_keyring=yes,
 612       ac_cv_linux_exports_key_type_keyring=no)])
 613   AC_MSG_RESULT($ac_cv_linux_exports_key_type_keyring)
 614   if test "x$ac_cv_linux_exports_key_type_keyring" = "xyes"; then
 615     AC_DEFINE([EXPORTED_KEY_TYPE_KEYRING], 1, [define if key_type_keyring is exported])
 616   fi])
 617
 618 AC_DEFUN([LINUX_KEYS_HAVE_SESSION_TO_PARENT], [
 619   AC_MSG_CHECKING([for KEYCTL_SESSION_TO_PARENT])
 620   AC_CACHE_VAL([ac_cv_linux_have_session_to_parent], [
 621     AC_TRY_KBUILD(
 622 [ #include <linux/keyctl.h>],
 623 [ int i = KEYCTL_SESSION_TO_PARENT;],
 624       ac_cv_linux_have_session_to_parent=yes,
 625       ac_cv_linux_have_session_to_parent=no)])
 626   AC_MSG_RESULT($ac_cv_linux_have_session_to_parent)
 627   if test "x$ac_cv_linux_have_session_to_parent" = "xyes"; then
 628     AC_DEFINE([HAVE_SESSION_TO_PARENT], 1, [define if keyctl has the KEYCTL_SESSION_TO_PARENT function])
 629   fi])
 630
 631 AC_DEFUN([LINUX_HAVE_TRY_TO_FREEZE], [
 632   AC_MSG_CHECKING([for try_to_freeze])
 633   AC_CACHE_CHECK([for try_to_freeze], [ac_cv_linux_have_try_to_freeze],
 634     [AC_TRY_KBUILD(
 635 [#include <linux/sched.h>
 636 #ifdef HAVE_LINUX_FREEZER_H
 637 #include <linux/freezer.h>
 638 #endif],
 639 [#ifdef LINUX_REFRIGERATOR_TAKES_PF_FREEZE
 640    try_to_freeze(PF_FREEZE);
 641 #else
 642    try_to_freeze();
 643 #endif
 644 ],
 645       ac_cv_linux_have_try_to_freeze=yes,
 646       ac_cv_linux_have_try_to_freeze=no)])
 647   AS_IF([test "x$ac_cv_linux_have_try_to_freeze" = "xyes"],
 648         [AC_DEFINE([HAVE_TRY_TO_FREEZE], 1,
 649                    [define if your kernel has the try_to_freeze function])])
 650  ])
 651