Linux: Add autoconf macro for structure checks
authorSimon Wilkinson <sxw@inf.ed.ac.uk>
Tue, 27 Apr 2010 12:02:20 +0000 (13:02 +0100)
committerDerrick Brashear <shadow@dementia.org>
Tue, 27 Apr 2010 19:23:34 +0000 (12:23 -0700)
Add a new autoconf macro for doing structure element checks, and
modify all simple structure checks to use it. This introduces a
standard name form - STRUCT_structure_HAS_element, so there are
some changes in the code to make use of this standard form.

Change-Id: Ife967322503ae6f428e76845000de04f26929e65
Reviewed-on: http://gerrit.openafs.org/1853
Reviewed-by: Derrick Brashear <shadow@dementia.org>
Tested-by: Derrick Brashear <shadow@dementia.org>

acinclude.m4
src/afs/LINUX/osi_compat.h
src/afs/LINUX/osi_vfsops.c
src/afs/LINUX/osi_vnodeops.c
src/afs/LINUX24/osi_vfsops.c
src/afs/LINUX24/osi_vnodeops.c
src/afs/afs.h
src/afs/afs_vcache.c
src/cf/linux-test1.m4
src/cf/linux-test3.m4
src/cf/linux-test4.m4

index 74e5edd..6cbf974 100644 (file)
@@ -61,12 +61,6 @@ AH_BOTTOM([
 #undef IRIX_HAS_MEM_FUNCS
 #undef RECALC_SIGPENDING_TAKES_VOID
 #undef STRUCT_FS_HAS_FS_ROLLED
-#undef STRUCT_INODE_HAS_I_ALLOC_SEM
-#undef STRUCT_TASK_STRUCT_HAS_PARENT
-#undef STRUCT_TASK_STRUCT_HAS_REAL_PARENT
-#undef STRUCT_TASK_STRUCT_HAS_SIG
-#undef STRUCT_TASK_STRUCT_HAS_SIGHAND
-#undef STRUCT_TASK_STRUCT_HAS_SIGMASK_LOCK
 #undef ssize_t
 #undef HAVE_ARPA_NAMESER_COMPAT_H
 /* glue for RedHat kernel bug */
@@ -810,7 +804,8 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*)
                 AC_CHECK_LINUX_FUNC([current_kernel_time],
                                     [#include <linux/time.h>],
                                   [struct timespec s = current_kernel_time();])
-                LINUX_HAVE_WRITE_BEGIN_AOP
+                AC_CHECK_LINUX_STRUCT([address_space_operations],
+                                      [write_begin], [fs.h])
                  AC_CHECK_LINUX_FUNC([bdi_init],
                                     [#include <linux/backing-dev.h>],
                                     [bdi_init(NULL);])
@@ -843,9 +838,8 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*)
                 AC_CHECK_LINUX_FUNC([kernel_setsockopt],
                                     [#include <linux/net.h>],
                                     [kernel_setsockopt(NULL, 0, 0, NULL, 0);])
-
-                 LINUX_STRUCT_TASK_HAS_CRED
-                LINUX_STRUCT_PROC_DIR_ENTRY_HAS_OWNER
+                 AC_CHECK_LINUX_STRUCT([task_struct], [cred], [sched.h])
+                AC_CHECK_LINUX_STRUCT([proc_dir_entry], [owner], [proc_fs.h])
                 LINUX_HAVE_KMEM_CACHE_T
                 LINUX_KMEM_CACHE_CREATE_CTOR_TAKES_VOID
                 LINUX_D_PATH_TAKES_STRUCT_PATH
@@ -856,14 +850,16 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*)
                 AC_CHECK_LINUX_HEADER([exportfs.h])
                 LINUX_DEFINES_FOR_EACH_PROCESS
                 LINUX_DEFINES_PREV_TASK
-                LINUX_FS_STRUCT_SUPER_HAS_ALLOC_INODE
-                LINUX_STRUCT_SUPER_BLOCK_HAS_S_BDI
-                LINUX_STRUCT_BDI_HAS_NAME
-                LINUX_FS_STRUCT_INODE_HAS_I_ALLOC_SEM
-                LINUX_FS_STRUCT_INODE_HAS_I_BLKBITS
-                LINUX_FS_STRUCT_INODE_HAS_I_BLKSIZE
-                LINUX_FS_STRUCT_INODE_HAS_I_MUTEX
-                LINUX_FS_STRUCT_INODE_HAS_I_SECURITY
+                AC_CHECK_LINUX_STRUCT([super_operations], [alloc_inode],
+                                      [fs.h])
+                AC_CHECK_LINUX_STRUCT([super_block], [s_bdi], [fs.h])
+                AC_CHECK_LINUX_STRUCT([backing_dev_info], [name],
+                                      [backing-dev.h])
+                AC_CHECK_LINUX_STRUCT([inode], [i_blksize], [fs.h])
+                AC_CHECK_LINUX_STRUCT([inode], [i_alloc_sem], [fs.h])
+                AC_CHECK_LINUX_STRUCT([inode], [i_blkbits], [fs.h])
+                AC_CHECK_LINUX_STRUCT([inode], [i_mutex], [fs.h])
+                AC_CHECK_LINUX_STRUCT([inode], [i_security], [fs.h])
                 LINUX_INODE_SETATTR_RETURN_TYPE
                 LINUX_IOP_I_CREATE_TAKES_NAMEIDATA
                 LINUX_IOP_I_LOOKUP_TAKES_NAMEIDATA
@@ -872,8 +868,8 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*)
                 LINUX_DOP_D_REVALIDATE_TAKES_NAMEIDATA
                 LINUX_FOP_F_FLUSH_TAKES_FL_OWNER_T
                 LINUX_AOP_WRITEBACK_CONTROL
-                LINUX_FS_STRUCT_FOP_HAS_FLOCK
-                LINUX_FS_STRUCT_FOP_HAS_SENDFILE
+                AC_CHECK_LINUX_STRUCT([file_operations], [flock], [fs.h])
+                AC_CHECK_LINUX_STRUCT([file_operations], [sendfile], [fs.h])
                 LINUX_FS_STRUCT_FOP_HAS_SPLICE
                 AC_CHECK_LINUX_HEADER([seq_file.h])
                 LINUX_KERNEL_POSIX_LOCK_FILE_WAIT_ARG
@@ -891,16 +887,16 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*)
                 LINUX_KEYS_HAVE_SESSION_TO_PARENT
                 LINUX_NEED_RHCONFIG
                 LINUX_RECALC_SIGPENDING_ARG_TYPE
-                LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_PARENT
-                LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_REAL_PARENT
-                LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_SIG
-                LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_SIGHAND
-                LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_SIGMASK_LOCK
-                LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_RLIM
+                AC_CHECK_LINUX_STRUCT([task_struct], [parent], [sched.h])
+                AC_CHECK_LINUX_STRUCT([task_struct], [real_parent], [sched.h])
+                AC_CHECK_LINUX_STRUCT([task_struct], [sig], [sched.h])
+                AC_CHECK_LINUX_STRUCT([task_struct], [sighand], [sched.h])
+                AC_CHECK_LINUX_STRUCT([task_struct], [sigmask_lock], [sched.h])
+                AC_CHECK_LINUX_STRUCT([task_struct], [rlim], [sched.h])
                 LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_SIGNAL_RLIM
-                LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_EXIT_STATE
-                LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_TGID
-                LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_THREAD_INFO
+                AC_CHECK_LINUX_STRUCT([task_struct], [exit_state], [sched.h])
+                AC_CHECK_LINUX_STRUCT([task_struct], [tgid], [sched.h])
+                AC_CHECK_LINUX_STRUCT([task_struct], [thread_info], [sched.h])
                 LINUX_EXPORTS_TASKLIST_LOCK
                 LINUX_GET_SB_HAS_STRUCT_VFSMOUNT
                 LINUX_STATFS_TAKES_DENTRY
@@ -920,7 +916,7 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*)
                 LINUX_INIT_WORK_HAS_DATA
                 LINUX_REGISTER_SYSCTL_TABLE_NOFLAG
                 LINUX_SYSCTL_TABLE_CHECKING
-                LINUX_STRUCT_CTL_TABLE_HAS_CTL_NAME
+                AC_CHECK_LINUX_FUNC([ctl_table], [ctl_name], [sysctl.h])
                 AC_CHECK_LINUX_FUNC([iget],
                                     [#include <linux/fs.h>],
                                     [iget(NULL, NULL);])
@@ -936,7 +932,7 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*)
                 AS_IF([test "x$ac_cv_linux_func_d_alloc_anon" = "xno"],
                       [AC_DEFINE([AFS_NONFSTRANS], 1,
                                  [define to disable the nfs translator])])
-                LINUX_FS_STRUCT_NAMEIDATA_HAS_PATH
+                AC_CHECK_LINUX_STRUCT([nameidata], [path], [namei.h])
                 LINUX_EXPORTS_INIT_MM
                  LINUX_EXPORTS_SYS_CHDIR
                  LINUX_EXPORTS_SYS_OPEN
@@ -1009,21 +1005,6 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*)
                 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_fs_struct_super_has_alloc_inode" = "xyes" ; then
-                 AC_DEFINE(STRUCT_SUPER_HAS_ALLOC_INODE, 1, [define if your struct super_operations has alloc_inode])
-                fi
-                if test "x$ac_cv_linux_fs_struct_inode_has_i_alloc_sem" = "xyes"; then 
-                 AC_DEFINE(STRUCT_INODE_HAS_I_ALLOC_SEM, 1, [define if your struct inode has alloc_sem])
-                fi
-                if test "x$ac_cv_linux_fs_struct_inode_has_i_blksize" = "xyes"; then 
-                 AC_DEFINE(STRUCT_INODE_HAS_I_BLKSIZE, 1, [define if your struct inode has i_blksize])
-                fi
-                if test "x$ac_cv_linux_fs_struct_inode_has_i_security" = "xyes"; then 
-                 AC_DEFINE(STRUCT_INODE_HAS_I_SECURITY, 1, [define if you struct inode has i_security])
-                fi
-                if test "x$ac_cv_linux_fs_struct_inode_has_i_mutex" = "xyes"; then 
-                 AC_DEFINE(STRUCT_INODE_HAS_I_MUTEX, 1, [define if you struct inode has i_mutex])
-                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
@@ -1033,39 +1014,6 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*)
                 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_sched_struct_task_struct_has_parent" = "xyes"; then 
-                 AC_DEFINE(STRUCT_TASK_STRUCT_HAS_PARENT, 1, [define if your struct task_struct has parent])
-                fi
-                if test "x$ac_cv_linux_sched_struct_task_struct_has_real_parent" = "xyes"; then 
-                 AC_DEFINE(STRUCT_TASK_STRUCT_HAS_REAL_PARENT, 1, [define if your struct task_struct has real_parent])
-                fi
-                if test "x$ac_cv_linux_sched_struct_task_struct_has_sigmask_lock" = "xyes"; then 
-                 AC_DEFINE(STRUCT_TASK_STRUCT_HAS_SIGMASK_LOCK, 1, [define if your struct task_struct has sigmask_lock])
-                fi
-                if test "x$ac_cv_linux_sched_struct_task_struct_has_sighand" = "xyes"; then 
-                 AC_DEFINE(STRUCT_TASK_STRUCT_HAS_SIGHAND, 1, [define if your struct task_struct has sighand])
-                fi
-                if test "x$ac_cv_linux_sched_struct_task_struct_has_sig" = "xyes"; then 
-                 AC_DEFINE(STRUCT_TASK_STRUCT_HAS_SIG, 1, [define if your struct task_struct has sig])
-                fi
-                if test "x$ac_cv_linux_sched_struct_task_struct_has_rlim" = "xyes"; then 
-                 AC_DEFINE(STRUCT_TASK_STRUCT_HAS_RLIM, 1, [define if your struct task_struct has rlim])
-                fi
-                if test "x$ac_cv_linux_sched_struct_task_struct_has_signal_rlim" = "xyes"; then 
-                 AC_DEFINE(STRUCT_TASK_STRUCT_HAS_SIGNAL_RLIM, 1, [define if your struct task_struct has signal->rlim])
-                fi
-                if test "x$ac_cv_linux_sched_struct_task_struct_has_exit_state" = "xyes"; then 
-                 AC_DEFINE(STRUCT_TASK_STRUCT_HAS_EXIT_STATE, 1, [define if your struct task_struct has exit_state])
-                fi
-                if test "x$ac_cv_linux_sched_struct_task_struct_has_tgid" = "xyes"; then 
-                 AC_DEFINE(STRUCT_TASK_STRUCT_HAS_TGID, 1, [define if your struct task_struct has tgid])
-                fi
-                if test "x$ac_cv_linux_sched_struct_task_struct_has_todo" = "xyes"; then 
-                 AC_DEFINE(STRUCT_TASK_STRUCT_HAS_TODO, 1, [define if your struct task_struct has todo])
-                fi
-                if test "x$ac_cv_linux_sched_struct_task_struct_has_thread_info" = "xyes"; then 
-                 AC_DEFINE(STRUCT_TASK_STRUCT_HAS_THREAD_INFO, 1, [define if your struct task_struct has thread_info])
-                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
@@ -1093,27 +1041,12 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*)
                 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_fs_struct_fop_has_flock" = "xyes" ; then
-                 AC_DEFINE(STRUCT_FILE_OPERATIONS_HAS_FLOCK, 1, [define if your struct file_operations has flock])
-                fi
-                if test "x$ac_cv_linux_fs_struct_fop_has_sendfile" = "xyes" ; then
-                 AC_DEFINE(STRUCT_FILE_OPERATIONS_HAS_SENDFILE, 1, [define if your struct file_operations has sendfile])
-                fi
-                if test "x$ac_cv_linux_fs_struct_fop_has_splice" = "xyes" ; then
-                 AC_DEFINE(STRUCT_FILE_OPERATIONS_HAS_SPLICE, 1, [define if your struct file_operations has splice_write and splice_read])
-                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_have_iget" = "xyes" ; then
-                 AC_DEFINE(HAVE_IGET, 1, [define if your kernel has iget])
-                fi
-                if test "x$ac_cv_linux_struct_nameidata_has_path" = "xyes" ; then
-                 AC_DEFINE(STRUCT_NAMEIDATA_HAS_PATH, 1, [define if your struct nameidata has path])
-                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
@@ -1126,9 +1059,6 @@ case $AFS_SYSNAME in *_linux* | *_umlinux*)
                 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_current_kernel_time" = "xyes" ; then
-                 AC_DEFINE(HAVE_CURRENT_KERNEL_TIME, 1, [define if current_kernel_time() exists])
-                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
index 665a708..39dfab5 100644 (file)
@@ -91,7 +91,7 @@ hlist_unhashed(const struct hlist_node *h) {
 #define AOP_WRITEPAGE_ACTIVATE WRITEPAGE_ACTIVATE
 #endif
 
-#if defined(HAVE_WRITE_BEGIN) && !defined(HAVE_LINUX_GRAB_CACHE_PAGE_WRITE_BEGIN)
+#if defined(STRUCT_ADDRESS_SPACE_OPERATIONS_HAS_WRITE_BEGIN) && !defined(HAVE_LINUX_GRAB_CACHE_PAGE_WRITE_BEGIN)
 static inline struct page *
 grab_cache_page_write_begin(struct address_space *mapping, pgoff_t index,
                            unsigned int flags) {
index 0b50b3d..b7d1c1a 100644 (file)
@@ -110,7 +110,7 @@ afs_fill_super(struct super_block *sb, void *data, int silent)
 #if defined(HAVE_LINUX_BDI_INIT)
     bdi_init(afs_backing_dev_info);
 #endif
-#if defined(STRUCT_BDI_HAS_NAME)
+#if defined(STRUCT_BACKING_DEV_INFO_HAS_NAME)
     afs_backing_dev_info->name = "openafs";
 #endif
     afs_backing_dev_info->ra_pages = 32;
@@ -222,7 +222,7 @@ afs_notify_change(struct dentry *dp, struct iattr *iattrp)
 }
 
 
-#if defined(STRUCT_SUPER_HAS_ALLOC_INODE)
+#if defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE)
 static afs_kmem_cache_t *afs_inode_cachep;
 
 static struct inode *
@@ -298,7 +298,7 @@ afs_clear_inode(struct inode *ip)
     if (vcp->hnext)
        osi_Panic("inode freed while still hashed");
 
-#if !defined(STRUCT_SUPER_HAS_ALLOC_INODE)
+#if !defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE)
     afs_osi_Free(ip->u.generic_ip, sizeof(struct vcache));
 #endif
 }
@@ -362,7 +362,7 @@ afs_statfs(struct super_block *sbp, struct kstatfs *statp)
 }
 
 struct super_operations afs_sops = {
-#if defined(STRUCT_SUPER_HAS_ALLOC_INODE)
+#if defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE)
   .alloc_inode =       afs_alloc_inode,
   .destroy_inode =     afs_destroy_inode,
 #endif
index b81af85..eb667cc 100644 (file)
@@ -2334,7 +2334,7 @@ afs_linux_prepare_write(struct file *file, struct page *page, unsigned from,
     return 0;
 }
 
-#if defined(HAVE_WRITE_BEGIN)
+#if defined(STRUCT_ADDRESS_SPACE_OPERATIONS_HAS_WRITE_BEGIN)
 static int
 afs_linux_write_end(struct file *file, struct address_space *mapping,
                                 loff_t pos, unsigned len, unsigned copied,
@@ -2384,7 +2384,7 @@ static struct address_space_operations afs_file_aops = {
   .readpage =          afs_linux_readpage,
   .readpages =                 afs_linux_readpages,
   .writepage =         afs_linux_writepage,
-#if defined (HAVE_WRITE_BEGIN)
+#if defined (STRUCT_ADDRESS_SPACE_OPERATIONS_HAS_WRITE_BEGIN)
   .write_begin =        afs_linux_write_begin,
   .write_end =          afs_linux_write_end,
 #else
index 52350d1..9b4906f 100644 (file)
@@ -205,7 +205,7 @@ afs_notify_change(struct dentry *dp, struct iattr *iattrp)
 }
 
 
-#if defined(STRUCT_SUPER_HAS_ALLOC_INODE)
+#if defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE)
 #if defined(HAVE_KMEM_CACHE_T)
 static kmem_cache_t *afs_inode_cachep;
 #else
@@ -307,7 +307,7 @@ afs_clear_inode(struct inode *ip)
     if (vcp->hnext)
        osi_Panic("inode freed while still hashed");
 
-#if !defined(STRUCT_SUPER_HAS_ALLOC_INODE)
+#if !defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE)
     afs_osi_Free(ip->u.generic_ip, sizeof(struct vcache));
 #endif
 }
@@ -391,7 +391,7 @@ afs_statfs(struct super_block *sbp, struct statfs *__statp, int size)
 }
 
 struct super_operations afs_sops = {
-#if defined(STRUCT_SUPER_HAS_ALLOC_INODE)
+#if defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE)
   .alloc_inode =       afs_alloc_inode,
   .destroy_inode =     afs_destroy_inode,
 #endif
index 6edb4a2..fe99387 100644 (file)
@@ -2309,7 +2309,7 @@ afs_linux_permission(struct inode *ip, int mode)
     return afs_convert_code(code);
 }
 
-#if defined(AFS_LINUX24_ENV) && !defined(HAVE_WRITE_BEGIN)
+#if defined(AFS_LINUX24_ENV) && !defined(STRUCT_ADDRESS_SPACE_OPERATIONS_HAS_WRITE_BEGIN)
 static int
 afs_linux_commit_write(struct file *file, struct page *page, unsigned offset,
                       unsigned to)
@@ -2334,7 +2334,7 @@ afs_linux_prepare_write(struct file *file, struct page *page, unsigned from,
 }
 #endif
 
-#if defined(HAVE_WRITE_BEGIN)
+#if defined(STRUCT_ADDRESS_SPACE_OPERATIONS_HAS_WRITE_BEGIN)
 static int
 afs_linux_write_end(struct file *file, struct address_space *mapping,
                                 loff_t pos, unsigned len, unsigned copied,
@@ -2387,7 +2387,7 @@ static struct address_space_operations afs_file_aops = {
   .readpage =          afs_linux_readpage,
   .readpages =                 afs_linux_readpages,
   .writepage =         afs_linux_writepage,
-#if defined (HAVE_WRITE_BEGIN)
+#if defined (STRUCT_ADDRESS_SPACE_OPERATIONS_HAS_WRITE_BEGIN)
   .write_begin =        afs_linux_write_begin,
   .write_end =          afs_linux_write_end,
 #else
index 4aaf335..a16a5a4 100644 (file)
@@ -688,7 +688,7 @@ extern afs_int32 vmPageHog; /* counter for # of vnodes which are page hogs. */
 #if defined(AFS_DARWIN80_ENV)
 #define VTOAFS(v) ((struct vcache *)vnode_fsnode((v)))
 #define AFSTOV(vc) ((vc)->v)
-#elif defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV) || (defined(AFS_LINUX22_ENV) && !defined(STRUCT_SUPER_HAS_ALLOC_INODE))
+#elif defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV) || (defined(AFS_LINUX22_ENV) && !defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE))
 #define VTOAFS(v) ((struct vcache *)(v)->v_data)
 #define AFSTOV(vc) ((vc)->v)
 #else
@@ -744,7 +744,7 @@ struct fvcache {
  * !(avc->nextfree) && !avc->vlruq.next => (FreeVCList == avc->nextfree)
  */
 struct vcache {
-#if defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV) || (defined(AFS_LINUX22_ENV) && !defined(STRUCT_SUPER_HAS_ALLOC_INODE))
+#if defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV) || (defined(AFS_LINUX22_ENV) && !defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE))
     struct vnode *v;
 #else
     struct vnode v;            /* Has reference count in v.v_count */
index d0563ff..51566e7 100644 (file)
@@ -721,7 +721,7 @@ afs_AllocVCache(void)
     if (!ip)
        osi_Panic("afs_AllocVCache: no more inodes");
     AFS_GLOCK();
-#if defined(STRUCT_SUPER_HAS_ALLOC_INODE)
+#if defined(STRUCT_SUPER_OPERATIONS_HAS_ALLOC_INODE)
     tvc = VTOAFS(ip);
 #else
     tvc = afs_osi_Alloc(sizeof(struct vcache));
index 496caa8..6545717 100644 (file)
@@ -116,3 +116,17 @@ AC_DEFUN([AC_CHECK_LINUX_FUNC],
                   [Define if your kernel has the $1 function])])
  ])
 
+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 <linux/$3>],
+                 [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])])
+ ])
+
index 577adfa..b70f819 100644 (file)
@@ -62,9 +62,3 @@ fi
 AC_SUBST(MPS)
 ])
 
-AC_DEFUN([LINUX_KERNEL_LINUX_SEQ_FILE_H],[
-  AC_MSG_CHECKING(for linux/seq_file.h in kernel)
-  AC_TRY_KBUILD([#include <linux/seq_file.h>], [],
-    [ac_linux_seq_file=yes], [ac_linux_seq_file=no])
-  AC_MSG_RESULT($ac_linux_seq_file)
-])
index 43497b7..5595285 100644 (file)
@@ -141,92 +141,6 @@ printk("%p\n", address);],
   AC_MSG_RESULT($ac_cv_linux_exports_sys_open)])
 
 
-AC_DEFUN([LINUX_FS_STRUCT_INODE_HAS_I_BLKSIZE], [
-  AC_MSG_CHECKING([for i_blksize in struct inode])
-  AC_CACHE_VAL([ac_cv_linux_fs_struct_inode_has_i_blksize], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct inode _inode;
-printk("%d\n", _inode.i_blksize);],
-      ac_cv_linux_fs_struct_inode_has_i_blksize=yes,
-      ac_cv_linux_fs_struct_inode_has_i_blksize=no)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_inode_has_i_blksize)])
-
-AC_DEFUN([LINUX_FS_STRUCT_INODE_HAS_I_BLKBITS], [
-  AC_MSG_CHECKING([for i_blkbits in struct inode])
-  AC_CACHE_VAL([ac_cv_linux_fs_struct_inode_has_i_blkbits], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct inode _inode;
-printk("%d\n", _inode.i_blkbits);],
-      ac_cv_linux_fs_struct_inode_has_i_blkbits=yes,
-      ac_cv_linux_fs_struct_inode_has_i_blkbits=no)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_inode_has_i_blkbits)
-  if test "x$ac_cv_linux_fs_struct_inode_has_i_blkbits" = "xyes"; then
-    AC_DEFINE(STRUCT_INODE_HAS_I_BLKBITS, 1, [define if your struct inode has i_blkbits])
-  fi])
-
-
-AC_DEFUN([LINUX_FS_STRUCT_INODE_HAS_I_CDEV], [
-  AC_MSG_CHECKING([for i_cdev in struct inode])
-  AC_CACHE_VAL([ac_cv_linux_fs_struct_inode_has_i_cdev], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct inode _inode;
-printk("%d\n", _inode.i_cdev);],
-      ac_cv_linux_fs_struct_inode_has_i_cdev=yes,
-      ac_cv_linux_fs_struct_inode_has_i_cdev=no)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_inode_has_i_cdev)])
-
-
-AC_DEFUN([LINUX_FS_STRUCT_INODE_HAS_I_MAPPING_OVERLOAD], [
-  AC_MSG_CHECKING([for i_mapping_overload in struct inode])
-  AC_CACHE_VAL([ac_cv_linux_fs_struct_inode_has_i_mapping_overload], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct inode _inode;
-printk("%d\n", _inode.i_mapping_overload);],
-      ac_cv_linux_fs_struct_inode_has_i_mapping_overload=yes,
-      ac_cv_linux_fs_struct_inode_has_i_mapping_overload=no)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_inode_has_i_mapping_overload)])
-
-
-AC_DEFUN([LINUX_FS_STRUCT_INODE_HAS_I_MMAP_SHARED], [
-  AC_MSG_CHECKING([for i_mmap_shared in struct inode])
-  AC_CACHE_VAL([ac_cv_linux_fs_struct_inode_has_i_mmap_shared], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct inode _inode;
-printk("%d\n", _inode.i_mmap_shared);],
-      ac_cv_linux_fs_struct_inode_has_i_mmap_shared=yes,
-      ac_cv_linux_fs_struct_inode_has_i_mmap_shared=no)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_inode_has_i_mmap_shared)])
-
-
-AC_DEFUN([LINUX_FS_STRUCT_INODE_HAS_I_MUTEX], [
-  AC_MSG_CHECKING([for i_mutex in struct inode])
-  AC_CACHE_VAL([ac_cv_linux_fs_struct_inode_has_i_mutex], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct inode _inode;
-printk("%d\n", _inode.i_mutex);],
-      ac_cv_linux_fs_struct_inode_has_i_mutex=yes,
-      ac_cv_linux_fs_struct_inode_has_i_mutex=no)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_inode_has_i_mutex)])
-
-
-AC_DEFUN([LINUX_FS_STRUCT_INODE_HAS_I_SECURITY], [
-  AC_MSG_CHECKING([for i_security in struct inode])
-  AC_CACHE_VAL([ac_cv_linux_fs_struct_inode_has_i_security], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct inode _inode;
-printk("%d\n", _inode.i_security);],
-      ac_cv_linux_fs_struct_inode_has_i_security=yes,
-      ac_cv_linux_fs_struct_inode_has_i_security=no)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_inode_has_i_security)])
-
-
 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], [
@@ -238,136 +152,19 @@ AC_DEFUN([LINUX_RECALC_SIGPENDING_ARG_TYPE], [
   AC_MSG_RESULT($ac_cv_linux_func_recalc_sigpending_takes_void)])
 
 
-AC_DEFUN([LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_PARENT], [
-  AC_MSG_CHECKING([for parent in struct task_struct])
-  AC_CACHE_VAL([ac_cv_linux_sched_struct_task_struct_has_parent], [
-    AC_TRY_KBUILD(
-[#include <linux/sched.h>],
-[struct task_struct _tsk;
-printk("%d\n", _tsk.parent);],
-      ac_cv_linux_sched_struct_task_struct_has_parent=yes,
-      ac_cv_linux_sched_struct_task_struct_has_parent=no)])
-  AC_MSG_RESULT($ac_cv_linux_sched_struct_task_struct_has_parent)])
-
-
-AC_DEFUN([LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_TGID], [
-  AC_MSG_CHECKING([for tgid in struct task_struct])
-  AC_CACHE_VAL([ac_cv_linux_sched_struct_task_struct_has_tgid], [
-    AC_TRY_KBUILD(
-[#include <linux/sched.h>],
-[struct task_struct _tsk;
-printk("%d\n", _tsk.tgid);],
-      ac_cv_linux_sched_struct_task_struct_has_tgid=yes,
-      ac_cv_linux_sched_struct_task_struct_has_tgid=no)])
-  AC_MSG_RESULT($ac_cv_linux_sched_struct_task_struct_has_tgid)])
-
-
-AC_DEFUN([LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_REAL_PARENT], [
-  AC_MSG_CHECKING([for real_parent in struct task_struct])
-  AC_CACHE_VAL([ac_cv_linux_sched_struct_task_struct_has_real_parent], [
-    AC_TRY_KBUILD(
-[#include <linux/sched.h>],
-[struct task_struct _tsk;
-printk("%d\n", _tsk.real_parent);],
-      ac_cv_linux_sched_struct_task_struct_has_real_parent=yes,
-      ac_cv_linux_sched_struct_task_struct_has_real_parent=no)])
-  AC_MSG_RESULT($ac_cv_linux_sched_struct_task_struct_has_real_parent)])
-
-
-AC_DEFUN([LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_SIG], [
-  AC_MSG_CHECKING([for sig in struct task_struct])
-  AC_CACHE_VAL([ac_cv_linux_sched_struct_task_struct_has_sig], [
-    AC_TRY_KBUILD(
-[#include <linux/sched.h>],
-[struct task_struct _tsk;
-printk("%d\n", _tsk.sig);],
-      ac_cv_linux_sched_struct_task_struct_has_sig=yes,
-      ac_cv_linux_sched_struct_task_struct_has_sig=no)])
-  AC_MSG_RESULT($ac_cv_linux_sched_struct_task_struct_has_sig)])
-
-
-AC_DEFUN([LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_SIGMASK_LOCK], [
-  AC_MSG_CHECKING([for sigmask_lock in struct task_struct])
-  AC_CACHE_VAL([ac_cv_linux_sched_struct_task_struct_has_sigmask_lock], [
-    AC_TRY_KBUILD(
-[#include <linux/sched.h>],
-[struct task_struct _tsk;
-printk("%d\n", _tsk.sigmask_lock);],
-      ac_cv_linux_sched_struct_task_struct_has_sigmask_lock=yes,
-      ac_cv_linux_sched_struct_task_struct_has_sigmask_lock=no)])
-  AC_MSG_RESULT($ac_cv_linux_sched_struct_task_struct_has_sigmask_lock)])
-
-
-AC_DEFUN([LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_SIGHAND], [
-  AC_MSG_CHECKING([for sighand in struct task_struct])
-  AC_CACHE_VAL([ac_cv_linux_sched_struct_task_struct_has_sighand], [
-    AC_TRY_KBUILD(
-[#include <linux/sched.h>],
-[struct task_struct _tsk;
-printk("%d\n", _tsk.sighand);],
-      ac_cv_linux_sched_struct_task_struct_has_sighand=yes,
-      ac_cv_linux_sched_struct_task_struct_has_sighand=no)])
-  AC_MSG_RESULT($ac_cv_linux_sched_struct_task_struct_has_sighand)])
-
-
-AC_DEFUN([LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_RLIM], [
-  AC_MSG_CHECKING([for rlim in struct task_struct])
-  AC_CACHE_VAL([ac_cv_linux_sched_struct_task_struct_has_rlim], [
-    AC_TRY_KBUILD(
-[#include <linux/sched.h>],
-[struct task_struct _tsk;
-printk("%d\n", _tsk.rlim);],
-      ac_cv_linux_sched_struct_task_struct_has_rlim=yes,
-      ac_cv_linux_sched_struct_task_struct_has_rlim=no)])
-  AC_MSG_RESULT($ac_cv_linux_sched_struct_task_struct_has_rlim)])
-
-
 AC_DEFUN([LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_SIGNAL_RLIM], [
-  AC_MSG_CHECKING([for signal->rlim in struct task_struct])
-  AC_CACHE_VAL([ac_cv_linux_sched_struct_task_struct_has_signal_rlim], [
-    AC_TRY_KBUILD(
+  AC_CACHE_CHECK([for signal->rlim in struct task_struct],
+   [ac_cv_linux_sched_struct_task_struct_has_signal_rlim],
+   [AC_TRY_KBUILD(
 [#include <linux/sched.h>],
 [struct task_struct _tsk;
 printk("%d\n", _tsk.signal->rlim);],
-      ac_cv_linux_sched_struct_task_struct_has_signal_rlim=yes,
-      ac_cv_linux_sched_struct_task_struct_has_signal_rlim=no)])
-  AC_MSG_RESULT($ac_cv_linux_sched_struct_task_struct_has_signal_rlim)])
-
-
-AC_DEFUN([LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_EXIT_STATE], [
-  AC_MSG_CHECKING([for exit_state in struct task_struct])
-  AC_CACHE_VAL([ac_cv_linux_sched_struct_task_struct_has_exit_state], [
-    AC_TRY_KBUILD(
-[#include <linux/sched.h>],
-[struct task_struct _tsk;
-printk("%d\n", _tsk.exit_state);],
-      ac_cv_linux_sched_struct_task_struct_has_exit_state=yes,
-      ac_cv_linux_sched_struct_task_struct_has_exit_state=no)])
-  AC_MSG_RESULT($ac_cv_linux_sched_struct_task_struct_has_exit_state)])
-
-
-AC_DEFUN([LINUX_SCHED_STRUCT_TASK_STRUCT_HAS_THREAD_INFO], [
-  AC_MSG_CHECKING([for thread_info in struct task_struct])
-  AC_CACHE_VAL([ac_cv_linux_sched_struct_task_struct_has_thread_info], [
-    AC_TRY_KBUILD(
-[#include <linux/sched.h>],
-[struct task_struct _tsk;
-printk("%d\n", _tsk.thread_info);],
-      ac_cv_linux_sched_struct_task_struct_has_thread_info=yes,
-      ac_cv_linux_sched_struct_task_struct_has_thread_info=no)])
-  AC_MSG_RESULT($ac_cv_linux_sched_struct_task_struct_has_thread_info)])
-
-
-AC_DEFUN([LINUX_FS_STRUCT_SUPER_HAS_ALLOC_INODE], [
-  AC_MSG_CHECKING([for alloc_inode in struct super_operations])
-  AC_CACHE_VAL([ac_cv_linux_fs_struct_super_has_alloc_inode], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct super_operations _super;
-printk("%p\n", _super.alloc_inode);],
-      ac_cv_linux_fs_struct_super_has_alloc_inode=yes,
-      ac_cv_linux_fs_struct_super_has_alloc_inode=no)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_super_has_alloc_inode)])
+      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_DEFUN([LINUX_KERNEL_POSIX_LOCK_FILE_WAIT_ARG], [
@@ -391,30 +188,6 @@ AC_DEFUN([LINUX_KERNEL_SOCK_CREATE], [
   AC_MSG_RESULT($ac_cv_linux_kernel_sock_create_v)])
 
 
-AC_DEFUN([LINUX_FS_STRUCT_INODE_HAS_I_BYTES], [
-  AC_MSG_CHECKING([for i_bytes in struct inode])
-  AC_CACHE_VAL([ac_cv_linux_fs_struct_inode_has_i_bytes], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct inode _inode;
-printk("%d\n", _inode.i_bytes);],
-      ac_cv_linux_fs_struct_inode_has_i_bytes=yes,
-      ac_cv_linux_fs_struct_inode_has_i_bytes=no)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_inode_has_i_bytes)])
-
-
-AC_DEFUN([LINUX_FS_STRUCT_INODE_HAS_I_ALLOC_SEM], [
-  AC_MSG_CHECKING([for i_alloc_sem in struct inode])
-  AC_CACHE_VAL([ac_cv_linux_fs_struct_inode_has_i_alloc_sem], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct inode _i;
-printk("%x\n", _i.i_alloc_sem);],
-      ac_cv_linux_fs_struct_inode_has_i_alloc_sem=yes,
-      ac_cv_linux_fs_struct_inode_has_i_alloc_sem=no)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_inode_has_i_alloc_sem)])
-
-
 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], [
@@ -637,18 +410,6 @@ INIT_WORK(w,f,i);],
       ac_cv_linux_init_work_has_data=no)])
   AC_MSG_RESULT($ac_cv_linux_init_work_has_data)])
 
-
-AC_DEFUN([LINUX_FS_STRUCT_FOP_HAS_FLOCK], [
-  AC_MSG_CHECKING([for flock in struct file_operations])
-  AC_CACHE_VAL([ac_cv_linux_fs_struct_fop_has_flock], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct file_operations _fop;
-_fop.flock(NULL, 0, NULL);],
-      ac_cv_linux_fs_struct_fop_has_flock=yes,
-      ac_cv_linux_fs_struct_fop_has_flock=no)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_fop_has_flock)])
-
 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], [
@@ -711,17 +472,6 @@ kmem_cache_create(NULL, 0, 0, 0, _ctor);],
     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_FS_STRUCT_FOP_HAS_SENDFILE], [
-  AC_MSG_CHECKING([for sendfile in struct file_operations])
-  AC_CACHE_VAL([ac_cv_linux_fs_struct_fop_has_sendfile], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct file_operations _fop;
-_fop.sendfile(NULL, NULL, 0, 0, NULL);],
-      ac_cv_linux_fs_struct_fop_has_sendfile=yes,
-      ac_cv_linux_fs_struct_fop_has_sendfile=no)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_fop_has_sendfile)])
-
 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], [
@@ -732,9 +482,12 @@ AC_DEFUN([LINUX_HAVE_SVC_ADDR_IN], [
       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_MSG_CHECKING([for splice_write and splice_read in struct file_operations])
-  AC_CACHE_VAL([ac_cv_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 <linux/fs.h>],
 [struct file_operations _fop;
@@ -742,7 +495,10 @@ _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)])
-  AC_MSG_RESULT($ac_cv_linux_fs_struct_fop_has_splice)])
+  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_DEFUN([LINUX_KMEM_CACHE_INIT], [
   AC_MSG_CHECKING([for new kmem_cache init function parameters])
@@ -768,17 +524,6 @@ sysctl_check_table(NULL);],
  ac_cv_linux_sysctl_table_checking=yes)])
 AC_MSG_RESULT($ac_cv_linux_sysctl_table_checking)])
 
-AC_DEFUN([LINUX_FS_STRUCT_NAMEIDATA_HAS_PATH], [
-  AC_MSG_CHECKING([for path in struct nameidata])
-  AC_CACHE_VAL([ac_cv_linux_struct_nameidata_has_path], [
-    AC_TRY_KBUILD(
-[#include <linux/namei.h>],
-[struct nameidata _nd;
-printk("%x\n", _nd.path);],
-      ac_cv_linux_struct_nameidata_has_path=yes,
-      ac_cv_linux_struct_nameidata_has_path=no)])
-  AC_MSG_RESULT($ac_cv_linux_struct_nameidata_has_path)])
-
 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], [
@@ -821,51 +566,6 @@ _eops.fh_to_parent(NULL, NULL, 0, 0);],
   fi])
  
 
-AC_DEFUN([LINUX_HAVE_WRITE_BEGIN_AOP], [
-  AC_MSG_CHECKING([for linux write_begin() address space op])
-  AC_CACHE_VAL([ac_cv_linux_write_begin], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct address_space_operations _aop;
-_aop.write_begin = NULL;],
-      ac_cv_linux_write_begin=yes,
-      ac_cv_linux_write_begin=no)])
-  AC_MSG_RESULT($ac_cv_linux_write_begin)
-  if test "x$ac_cv_linux_write_begin" = "xyes"; then
-    AC_DEFINE([HAVE_WRITE_BEGIN], 1, [define if your kernel has a write_begin() address space op])
-  fi])
-
-
-AC_DEFUN([LINUX_STRUCT_TASK_HAS_CRED], [
-  AC_MSG_CHECKING([if struct task has cred])
-  AC_CACHE_VAL([ac_cv_linux_struct_task_has_cred], [
-    AC_TRY_KBUILD(
-[#include <linux/sched.h>
-#include <linux/cred.h>],
-[struct task_struct _t;
-uid_t _u;
-_u =_t.cred->uid ;],
-      ac_cv_linux_struct_task_has_cred=yes,
-      ac_cv_linux_struct_task_has_cred=no)])
-  AC_MSG_RESULT($ac_cv_linux_struct_task_has_cred)
-  if test "x$ac_cv_linux_struct_task_has_cred" = "xyes"; then
-    AC_DEFINE([STRUCT_TASK_HAS_CRED], 1, [define if struct task has a cred pointer])
-  fi])
-
-AC_DEFUN([LINUX_STRUCT_PROC_DIR_ENTRY_HAS_OWNER], [
-  AC_MSG_CHECKING([if struct proc_dir_entry_has_owner])
-  AC_CACHE_VAL([ac_cv_linux_struct_proc_dir_entry_has_owner], [
-    AC_TRY_KBUILD(
-[#include <linux/proc_fs.h>],
-[struct proc_dir_entry _p;
-_p.owner= "";],
-      ac_cv_linux_struct_proc_dir_entry_has_owner=yes,
-      ac_cv_linux_struct_proc_dir_entry_has_owner=no)])
-  AC_MSG_RESULT($ac_cv_linux_struct_proc_dir_entry_has_owner)
-  if test "x$ac_cv_linux_struct_proc_dir_entry_has_owner" = "xyes"; then
-    AC_DEFINE([STRUCT_PROC_DIR_ENTRY_HAS_OWNER], 1, [define if struct proc_dir_entry has an owner member])
-  fi])
-
 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], [
@@ -928,49 +628,6 @@ AC_DEFUN([LINUX_KEYS_HAVE_SESSION_TO_PARENT], [
     AC_DEFINE([HAVE_SESSION_TO_PARENT], 1, [define if keyctl has the KEYCTL_SESSION_TO_PARENT function])
   fi])
 
-AC_DEFUN([LINUX_STRUCT_SUPER_BLOCK_HAS_S_BDI], [
-  AC_MSG_CHECKING([if struct super_block has s_bdi])
-  AC_CACHE_VAL([ac_cv_linux_struct_super_block_has_s_bdi], [
-    AC_TRY_KBUILD(
-[#include <linux/fs.h>],
-[struct super_block _sb;
-_sb.s_bdi= NULL;],
-      ac_cv_linux_struct_super_block_has_s_bdi=yes,
-      ac_cv_linux_struct_super_block_has_s_bdi=no)])
-  AC_MSG_RESULT($ac_cv_linux_struct_super_block_has_s_bdi)
-  if test "x$ac_cv_linux_struct_super_block_has_s_bdi" = "xyes"; then
-    AC_DEFINE([STRUCT_SUPER_BLOCK_HAS_S_BDI], 1, [define if struct super_block has an s_bdi member])
-  fi])
-
-AC_DEFUN([LINUX_STRUCT_CTL_TABLE_HAS_CTL_NAME], [
-  AC_MSG_CHECKING([if struct ctl_table has ctl_name])
-  AC_CACHE_VAL([ac_cv_linux_struct_ctl_table_has_ctl_name], [
-    AC_TRY_KBUILD(
-[#include <linux/sysctl.h>],
-[struct ctl_table _t;
-_t.ctl_name = 0;],
-      ac_cv_linux_struct_ctl_table_has_ctl_name=yes,
-      ac_cv_linux_struct_ctl_table_has_ctl_name=no)])
-  AC_MSG_RESULT($ac_cv_linux_struct_ctl_table_has_ctl_name)
-  if test "x$ac_cv_linux_struct_ctl_table_has_ctl_name" = "xyes"; then
-    AC_DEFINE([STRUCT_CTL_TABLE_HAS_CTL_NAME], 1, [define if struct ctl_table has a ctl_name member])
-  fi])
-
-AC_DEFUN([LINUX_STRUCT_BDI_HAS_NAME], [
-  AC_MSG_CHECKING([if struct backing_dev_info has name])
-  AC_CACHE_VAL([ac_cv_linux_struct_bdi_has_name], [
-    AC_TRY_KBUILD(
-[#include <linux/backing-dev.h>],
-[struct backing_dev_info _bdi;
-_bdi.name = NULL;],
-      ac_cv_linux_struct_bdi_has_name=yes,
-      ac_cv_linux_struct_bdi_has_name=no)])
-  AC_MSG_RESULT($ac_cv_linux_struct_bdi_has_name)
-  if test "x$ac_cv_linux_struct_bdi_has_name" = "xyes"; then
-    AC_DEFINE([STRUCT_BDI_HAS_NAME], 1, [define if struct backing_dev_info has a name member])
-  fi])
-
-
 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],