src/cf/linux-test4.m4

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