Merge pull request #26 from boxbackup/fix_raidfile_i386

Fix raidfile tests on 32-bit Linux.

A recent fix for Solaris (commit 81e9aa6545f7f19124c9f5e88982b867d8732965) broke support for 32-bit Linux (which wasn't spotted at the time, because we didn't have any 32-bit builders). Try a different approach: detect explicitly whether the `lseek` syscall takes a 64-bit integer offset, regardless of the size of `off_t` in user space.
    
CMake: Add support for M4 CXX flag detection in CMakeLists. Reimplement autoconf tests for 64-bit lseek.

Fix error in t-gdb when no debugger is detected.

Thanks to Reinhard Tartler (our Debian package maintainer) for pointing out the error, and James O'Gorman for setting up i386 builders to ensure that it's fixed and cannot recur.

2 files changed, 98 insertions, 51 deletions

diff --git a/infrastructure/m4/ax_check_syscall_lseek.m4 b/infrastructure/m4/ax_check_syscall_lseek.m4
index 9fd04c81..4fec851a 100644
--- a/infrastructure/m4/ax_check_syscall_lseek.m4
+++ b/infrastructure/m4/ax_check_syscall_lseek.m4
@@ -11,12 +11,14 @@ dnl @category C
 dnl @author Martin Ebourne
 dnl @version 2005/07/03
 dnl @license AllPermissive
+dnl
 
-AC_DEFUN([AX_CHECK_SYSCALL_LSEEK], [
-  AC_REQUIRE([AX_FUNC_SYSCALL])dnl
-  if test "x$ac_cv_header_sys_syscall_h" = "xyes"; then
-    AC_CACHE_CHECK([[whether syscall lseek requires dummy parameter]], [box_cv_have_lseek_dummy_param],
-      [AC_TRY_RUN(
+AC_DEFUN(
+  [AX_TRY_RUN_FD],
+  [
+    AC_REQUIRE([AX_FUNC_SYSCALL])dnl
+    if test "x$ac_cv_header_sys_syscall_h" = "xyes"; then
+      AC_TRY_RUN(
         [
           $ac_includes_default
           #include <fcntl.h>
@@ -30,40 +32,83 @@ AC_DEFUN([AX_CHECK_SYSCALL_LSEEK], [
           #endif
           int main()
           {
-          int fh = creat("lseektest", 0600);
-          int res = 0;
-          if(fh>=0)
+          int fd = creat("lseektest", 0600);
+          int res = 1;
+          if(fd>=0)
           {
+            $1
+            close(fd);
+          }
+          unlink("lseektest");
+          return abs(res);
+          }
+        ],
+        [$2],
+	[$3],
+	[$3 # assume not for cross-compiling]
+      )
+    fi
+  ])dnl
+
+AC_DEFUN([AX_CHECK_SYSCALL_LSEEK_DUMMY_PARAM], [
+  AC_CACHE_CHECK(
+    [[whether syscall lseek requires dummy parameter]],
+    [box_cv_have_lseek_dummy_param],
+    [AX_TRY_RUN_FD(
+      [
             // This test tries first to seek to position 0, with NO
             // "dummy argument". If lseek does actually require a dummy
             // argument, then it will eat SEEK_SET for the offset and
             // try to use 99 as whence, which is invalid, so res will be
-            // -1, the program will return zero and 
-            // have_lseek_dummy_param=yes 
+            // 1, the program will return 1 and we will define
+            // HAVE_LSEEK_DUMMY_PARAM
             // (whew! that took 1 hour to figure out)
             // The "dummy argument" probably means that it takes a 64-bit
-            // offset, so this was probably a bug anyway, and now that
-            // we cast the offset to off_t, it should never be needed
-            // (if my reasoning is correct).
-            res = syscall(SYS_lseek, fh, (off_t)0, SEEK_SET, 99);
-            close(fh);
-          }
-          unlink("lseektest");
-          return res!=-1;
-          }
-        ],
-        [box_cv_have_lseek_dummy_param=yes],
-	[box_cv_have_lseek_dummy_param=no],
-	[box_cv_have_lseek_dummy_param=no # assume not for cross-compiling]
-      )])
-    if test "x$box_cv_have_lseek_dummy_param" = "xyes"; then
-      AC_DEFINE([HAVE_LSEEK_DUMMY_PARAM], 1,
-                [Define to 1 if syscall lseek requires a dummy middle parameter])
-    fi
+            // offset.
+            res = (syscall(SYS_lseek, fd, (int32_t)10, SEEK_SET, 99) == 10) ? 0 : 1;
+      ],
+      dnl if the test program succeeds (res == 0):
+      [box_cv_have_lseek_dummy_param=no],
+      dnl if the test program fails (res != 0):
+      [box_cv_have_lseek_dummy_param=yes],
+    )]
+  )
+  if test "x$box_cv_have_lseek_dummy_param" != "xno"; then
+    AC_DEFINE([HAVE_LSEEK_DUMMY_PARAM], 1,
+              [Define to 1 if syscall lseek requires a dummy middle parameter])
   fi
-  if test "x$box_cv_have_lseek_dummy_param" = "xno"
-  then
-    m4_ifvaln([$1],[$1],[:])dnl
-    m4_ifvaln([$2],[else $2])dnl
+])
+
+# Please note: this does not appear to work! Do not rely on it without further testing:
+AC_DEFUN([AX_CHECK_SYSCALL_LSEEK_64_BIT], [
+  AC_CACHE_CHECK(
+    [[whether syscall lseek takes a 64-bit offset parameter]],
+    [box_cv_have_lseek_64_bit],
+    [AX_TRY_RUN_FD(
+      [
+            // Try to seek to a position that requires a 64-bit representation, and check the return
+            // value, which is the current position.
+            if(syscall(SYS_lseek, fd, (int64_t)5, SEEK_SET) != 5)
+            {
+              res = 2;
+            }
+            else if(syscall(SYS_lseek, fd, (int64_t)10, SEEK_CUR) != 15)
+            {
+              res = 3;
+            }
+            else
+            {
+              res = 0;
+            }
+      ],
+      dnl if the test program succeeds (res == 0):
+      [box_cv_have_lseek_64_bit=yes],
+      dnl if the test program fails (res != 0):
+      [box_cv_have_lseek_64_bit=no]
+    )]
+  )
+  if test "x$box_cv_have_lseek_64_bit" != "xno"; then
+    AC_DEFINE([HAVE_LSEEK_64_BIT], 1,
+              [Define to 1 if syscall lseek takes a 64-bit offset])
   fi
-  ])dnl
+])
diff --git a/infrastructure/m4/boxbackup_tests.m4 b/infrastructure/m4/boxbackup_tests.m4
index 59467e66..86aa560a 100644
--- a/infrastructure/m4/boxbackup_tests.m4
+++ b/infrastructure/m4/boxbackup_tests.m4
@@ -10,27 +10,28 @@ solaris*)
   ;;
 esac
 
+# If the compiler supports it, force errors on unknown flags, so that detection works:
+AX_CHECK_COMPILE_FLAG(-Werror=unknown-warning-option,
+	[cxxflags_force_error="-Werror=unknown-warning-option"])
+
+# Reduce compiler flag checking to a one-liner, needed for CMake to parse them
+AC_DEFUN([BOX_CHECK_CXX_FLAG],
+	AX_CHECK_COMPILE_FLAG($1,
+		[cxxflags_strict="$cxxflags_strict $1"],,
+		$cxxflags_force_error)
+)
+
 # Enable some compiler flags if the compiler supports them. This gives better warnings
 # and detects some problems early.
-AX_CHECK_COMPILE_FLAG(-Wall, [cxxflags_strict="$cxxflags_strict -Wall"])
-# -Wundef would be a good idea, but Boost is full of undefined variable use, so we need
-# to disable it for now so that we can concentrate on real errors:
-dnl AX_CHECK_COMPILE_FLAG(-Wundef, [cxxflags_strict="$cxxflags_strict -Wundef"])
-AX_CHECK_COMPILE_FLAG(-Werror=return-type,
-	[cxxflags_strict="$cxxflags_strict -Werror=return-type"])
-AX_CHECK_COMPILE_FLAG(-Werror=delete-non-virtual-dtor,
-	[cxxflags_strict="$cxxflags_strict -Werror=delete-non-virtual-dtor"])
-AX_CHECK_COMPILE_FLAG(-Werror=undefined-bool-conversion,
-	[cxxflags_strict="$cxxflags_strict -Werror=undefined-bool-conversion"])
-# We should really enable -Werror=sometimes-uninitialized, but QDBM violates it:
-dnl AX_CHECK_COMPILE_FLAG(-Werror=sometimes-uninitialized,
-dnl 	[cxxflags_strict="$cxxflags_strict -Werror=sometimes-uninitialized"])
+BOX_CHECK_CXX_FLAG(-Wall)
+BOX_CHECK_CXX_FLAG(-Werror=return-type)
+BOX_CHECK_CXX_FLAG(-Werror=delete-non-virtual-dtor)
+BOX_CHECK_CXX_FLAG(-Werror=undefined-bool-conversion)
 # This error is detected by MSVC, but not usually by GCC/Clang:
 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58114
-AX_CHECK_COMPILE_FLAG(-Werror=delete-incomplete,
-	[cxxflags_strict="$cxxflags_strict -Werror=delete-incomplete"])
-AX_CHECK_COMPILE_FLAG(-Wno-deprecated-declarations,
-	[cxxflags_strict="$cxxflags_strict -Wno-deprecated-declarations"])
+BOX_CHECK_CXX_FLAG(-Werror=delete-incomplete)
+BOX_CHECK_CXX_FLAG(-Wno-deprecated-declarations)
+
 AC_SUBST([CXXFLAGS_STRICT], [$cxxflags_strict])
 
 if test "x$GXX" = "xyes"; then
@@ -310,7 +311,8 @@ if test "$netbsd_hack" != "netbsd"; then
 fi
 
 AX_FUNC_SYSCALL
-AX_CHECK_SYSCALL_LSEEK
+AX_CHECK_SYSCALL_LSEEK_DUMMY_PARAM
+AX_CHECK_SYSCALL_LSEEK_64_BIT
 AC_CHECK_FUNCS([listxattr llistxattr getxattr lgetxattr setxattr lsetxattr])
 AC_CHECK_DECLS([XATTR_NOFOLLOW],,, [[#include <sys/xattr.h>]])