Perform KABI checks in parallel

Reduce the time required for ./configure to perform the needed
KABI checks by allowing kbuild to compile multiple test cases in
parallel.  This was accomplished by splitting each test's source
code from the logic handling whether that code could be compiled
or not.

By introducing this split it's possible to minimize the number of
times kbuild needs to be invoked.  As importantly, it means all of
the tests can be built in parallel.  This does require a little extra
care since we expect some tests to fail, so the --keep-going (-k)
option must be provided otherwise some tests may not get compiled.
Furthermore, since a failure during the kbuild modpost phase will
result in an early exit; the final linking phase is limited to tests
which passed the initial compilation and produced an object file.

Once everything has been built the configure script proceeds as
previously.  The only significant difference is that it now merely
needs to test for the existence of a .ko file to determine the
result of a given test.  This vastly speeds up the entire process.

New test cases should use ZFS_LINUX_TEST_SRC to declare their test
source code and ZFS_LINUX_TEST_RESULT to check the result.  All of
the existing kernel-*.m4 files have been updated accordingly, see
config/kernel-current-time.m4 for a basic example.  The legacy
ZFS_LINUX_TRY_COMPILE macro has been kept to handle special cases
but it's use is not encouraged.

                  master (secs)   patched (secs)
                  -------------   ----------------
autogen.sh        61              68
configure         137             24  (~17% of current run time)
make -j $(nproc)  44              44
make rpms         287             150

Reviewed-by: Tony Hutter <[email protected]>
Signed-off-by: Brian Behlendorf <[email protected]>
Closes #8547 
Closes #9132
Closes #9341 

1 files changed, 128 insertions, 91 deletions

diff --git a/config/kernel-shrink.m4 b/config/kernel-shrink.m4
index 405cbf42c..45b4b5d4b 100644
--- a/config/kernel-shrink.m4
+++ b/config/kernel-shrink.m4
@@ -4,9 +4,8 @@ dnl # The super_block structure now stores a per-filesystem shrinker.
 dnl # This interface is preferable because it can be used to specifically
 dnl # target only the zfs filesystem for pruning.
 dnl #
-AC_DEFUN([ZFS_AC_KERNEL_SHRINK], [
-	AC_MSG_CHECKING([whether super_block has s_shrink])
-	ZFS_LINUX_TRY_COMPILE([
+AC_DEFUN([ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK], [
+	ZFS_LINUX_TEST_SRC([super_block_s_shrink], [
 		#include <linux/fs.h>
 
 		int shrink(struct shrinker *s, struct shrink_control *sc)
@@ -18,8 +17,12 @@ AC_DEFUN([ZFS_AC_KERNEL_SHRINK], [
 			.s_shrink.seeks = DEFAULT_SEEKS,
 			.s_shrink.batch = 0,
 		};
-	],[
-	],[
+	],[])
+])
+
+AC_DEFUN([ZFS_AC_KERNEL_SUPER_BLOCK_S_SHRINK], [
+	AC_MSG_CHECKING([whether super_block has s_shrink])
+	ZFS_LINUX_TEST_RESULT([super_block_s_shrink], [
 		AC_MSG_RESULT(yes)
 		AC_DEFINE(HAVE_SHRINK, 1, [struct super_block has s_shrink])
 
@@ -50,15 +53,18 @@ dnl # a list_head is used.  Then to prevent the spinning from occurring
 dnl # the .next pointer is set to the fs_supers list_head which ensures
 dnl # the iterate_supers_type() function will always terminate.
 dnl #
-AC_DEFUN([ZFS_AC_KERNEL_S_INSTANCES_LIST_HEAD], [
-	AC_MSG_CHECKING([whether super_block has s_instances list_head])
-	ZFS_LINUX_TRY_COMPILE([
+AC_DEFUN([ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_INSTANCES_LIST_HEAD], [
+	ZFS_LINUX_TEST_SRC([super_block_s_instances_list_head], [
 		#include <linux/fs.h>
 	],[
 		struct super_block sb __attribute__ ((unused));
-
 		INIT_LIST_HEAD(&sb.s_instances);
-	],[
+	])
+])
+
+AC_DEFUN([ZFS_AC_KERNEL_SUPER_BLOCK_S_INSTANCES_LIST_HEAD], [
+	AC_MSG_CHECKING([whether super_block has s_instances list_head])
+	ZFS_LINUX_TEST_RESULT([super_block_s_instances_list_head], [
 		AC_MSG_RESULT(yes)
 		AC_DEFINE(HAVE_S_INSTANCES_LIST_HEAD, 1,
 		    [struct super_block has s_instances list_head])
@@ -67,9 +73,8 @@ AC_DEFUN([ZFS_AC_KERNEL_S_INSTANCES_LIST_HEAD], [
 	])
 ])
 
-AC_DEFUN([ZFS_AC_KERNEL_NR_CACHED_OBJECTS], [
-	AC_MSG_CHECKING([whether sops->nr_cached_objects() exists])
-	ZFS_LINUX_TRY_COMPILE([
+AC_DEFUN([ZFS_AC_KERNEL_SRC_NR_CACHED_OBJECTS], [
+	ZFS_LINUX_TEST_SRC([nr_cached_objects], [
 		#include <linux/fs.h>
 
 		int nr_cached_objects(struct super_block *sb) { return 0; }
@@ -78,19 +83,22 @@ AC_DEFUN([ZFS_AC_KERNEL_NR_CACHED_OBJECTS], [
 		    sops __attribute__ ((unused)) = {
 			.nr_cached_objects = nr_cached_objects,
 		};
-	],[
-	],[
+	],[])
+])
+
+AC_DEFUN([ZFS_AC_KERNEL_NR_CACHED_OBJECTS], [
+	AC_MSG_CHECKING([whether sops->nr_cached_objects() exists])
+	ZFS_LINUX_TEST_RESULT([nr_cached_objects], [
 		AC_MSG_RESULT(yes)
 		AC_DEFINE(HAVE_NR_CACHED_OBJECTS, 1,
-			[sops->nr_cached_objects() exists])
+		    [sops->nr_cached_objects() exists])
 	],[
 		AC_MSG_RESULT(no)
 	])
 ])
 
-AC_DEFUN([ZFS_AC_KERNEL_FREE_CACHED_OBJECTS], [
-	AC_MSG_CHECKING([whether sops->free_cached_objects() exists])
-	ZFS_LINUX_TRY_COMPILE([
+AC_DEFUN([ZFS_AC_KERNEL_SRC_FREE_CACHED_OBJECTS], [
+	ZFS_LINUX_TEST_SRC([free_cached_objects], [
 		#include <linux/fs.h>
 
 		void free_cached_objects(struct super_block *sb, int x)
@@ -100,11 +108,15 @@ AC_DEFUN([ZFS_AC_KERNEL_FREE_CACHED_OBJECTS], [
 		    sops __attribute__ ((unused)) = {
 			.free_cached_objects = free_cached_objects,
 		};
-	],[
-	],[
+	],[])
+])
+
+AC_DEFUN([ZFS_AC_KERNEL_FREE_CACHED_OBJECTS], [
+	AC_MSG_CHECKING([whether sops->free_cached_objects() exists])
+	ZFS_LINUX_TEST_RESULT([free_cached_objects], [
 		AC_MSG_RESULT(yes)
 		AC_DEFINE(HAVE_FREE_CACHED_OBJECTS, 1,
-			[sops->free_cached_objects() exists])
+		    [sops->free_cached_objects() exists])
 	],[
 		AC_MSG_RESULT(no)
 	])
@@ -115,15 +127,19 @@ dnl # 3.12 API change
 dnl # The nid member was added to struct shrink_control to support
 dnl # NUMA-aware shrinkers.
 dnl #
-AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID], [
-	AC_MSG_CHECKING([whether shrink_control has nid])
-	ZFS_LINUX_TRY_COMPILE([
+AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_HAS_NID], [
+	ZFS_LINUX_TEST_SRC([shrink_control_nid], [
 		#include <linux/fs.h>
 	],[
 		struct shrink_control sc __attribute__ ((unused));
 		unsigned long scnidsize __attribute__ ((unused)) =
 		    sizeof(sc.nid);
-	],[
+	])
+])
+
+AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID], [
+	AC_MSG_CHECKING([whether shrink_control has nid])
+	ZFS_LINUX_TEST_RESULT([shrink_control_nid], [
 		AC_MSG_RESULT(yes)
 		AC_DEFINE(SHRINK_CONTROL_HAS_NID, 1,
 		    [struct shrink_control has nid])
@@ -132,84 +148,96 @@ AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID], [
 	])
 ])
 
+AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER_CALLBACK], [
+	ZFS_LINUX_TEST_SRC([shrinker_cb_2arg], [
+		#include <linux/mm.h>
+		int shrinker_cb(int nr_to_scan, gfp_t gfp_mask) { return 0; }
+	],[
+		struct shrinker cache_shrinker = {
+			.shrink = shrinker_cb,
+			.seeks = DEFAULT_SEEKS,
+		};
+		register_shrinker(&cache_shrinker);
+	])
 
-AC_DEFUN([ZFS_AC_KERNEL_SHRINKER_CALLBACK],[
-	tmp_flags="$EXTRA_KCFLAGS"
-	EXTRA_KCFLAGS="-Werror"
-	dnl #
-	dnl # 2.6.23 to 2.6.34 API change
-	dnl # ->shrink(int nr_to_scan, gfp_t gfp_mask)
-	dnl #
-	AC_MSG_CHECKING([whether old 2-argument shrinker exists])
-	ZFS_LINUX_TRY_COMPILE([
+	ZFS_LINUX_TEST_SRC([shrinker_cb_3arg], [
 		#include <linux/mm.h>
+		int shrinker_cb(struct shrinker *shrink, int nr_to_scan,
+		    gfp_t gfp_mask) { return 0; }
+	],[
+		struct shrinker cache_shrinker = {
+			.shrink = shrinker_cb,
+			.seeks = DEFAULT_SEEKS,
+		};
+		register_shrinker(&cache_shrinker);
+	])
 
-		int shrinker_cb(int nr_to_scan, gfp_t gfp_mask) {
-			return 0;
-		}
+	ZFS_LINUX_TEST_SRC([shrinker_cb_shrink_control], [
+		#include <linux/mm.h>
+		int shrinker_cb(struct shrinker *shrink,
+		    struct shrink_control *sc) { return 0; }
 	],[
 		struct shrinker cache_shrinker = {
 			.shrink = shrinker_cb,
 			.seeks = DEFAULT_SEEKS,
 		};
 		register_shrinker(&cache_shrinker);
+	])
+
+	ZFS_LINUX_TEST_SRC([shrinker_cb_shrink_control_split], [
+		#include <linux/mm.h>
+		unsigned long shrinker_cb(struct shrinker *shrink,
+		    struct shrink_control *sc) { return 0; }
 	],[
+		struct shrinker cache_shrinker = {
+			.count_objects = shrinker_cb,
+			.scan_objects = shrinker_cb,
+			.seeks = DEFAULT_SEEKS,
+		};
+		register_shrinker(&cache_shrinker);
+	])
+])
+
+AC_DEFUN([ZFS_AC_KERNEL_SHRINKER_CALLBACK],[
+	dnl #
+	dnl # 2.6.23 to 2.6.34 API change
+	dnl # ->shrink(int nr_to_scan, gfp_t gfp_mask)
+	dnl #
+	AC_MSG_CHECKING([whether old 2-argument shrinker exists])
+	ZFS_LINUX_TEST_RESULT([shrinker_cb_2arg], [
 		AC_MSG_RESULT(yes)
 		AC_DEFINE(HAVE_2ARGS_OLD_SHRINKER_CALLBACK, 1,
-			[old shrinker callback wants 2 args])
+		    [old shrinker callback wants 2 args])
 	],[
 		AC_MSG_RESULT(no)
+
 		dnl #
 		dnl # 2.6.35 - 2.6.39 API change
 		dnl # ->shrink(struct shrinker *,
 		dnl #          int nr_to_scan, gfp_t gfp_mask)
 		dnl #
 		AC_MSG_CHECKING([whether old 3-argument shrinker exists])
-		ZFS_LINUX_TRY_COMPILE([
-			#include <linux/mm.h>
-
-			int shrinker_cb(struct shrinker *shrink, int nr_to_scan,
-					gfp_t gfp_mask) {
-				return 0;
-			}
-		],[
-			struct shrinker cache_shrinker = {
-				.shrink = shrinker_cb,
-				.seeks = DEFAULT_SEEKS,
-			};
-			register_shrinker(&cache_shrinker);
-		],[
+		ZFS_LINUX_TEST_RESULT([shrinker_cb_3arg], [
 			AC_MSG_RESULT(yes)
 			AC_DEFINE(HAVE_3ARGS_SHRINKER_CALLBACK, 1,
 				[old shrinker callback wants 3 args])
 		],[
 			AC_MSG_RESULT(no)
+
 			dnl #
 			dnl # 3.0 - 3.11 API change
 			dnl # ->shrink(struct shrinker *,
 			dnl #          struct shrink_control *sc)
 			dnl #
 			AC_MSG_CHECKING(
-				[whether new 2-argument shrinker exists])
-			ZFS_LINUX_TRY_COMPILE([
-				#include <linux/mm.h>
-
-				int shrinker_cb(struct shrinker *shrink,
-						struct shrink_control *sc) {
-					return 0;
-				}
-			],[
-				struct shrinker cache_shrinker = {
-					.shrink = shrinker_cb,
-					.seeks = DEFAULT_SEEKS,
-				};
-				register_shrinker(&cache_shrinker);
-			],[
+			    [whether new 2-argument shrinker exists])
+			ZFS_LINUX_TEST_RESULT([shrinker_cb_shrink_control], [
 				AC_MSG_RESULT(yes)
 				AC_DEFINE(HAVE_2ARGS_NEW_SHRINKER_CALLBACK, 1,
 					[new shrinker callback wants 2 args])
 			],[
 				AC_MSG_RESULT(no)
+
 				dnl #
 				dnl # 3.12 API change,
 				dnl # ->shrink() is logically split in to
@@ -217,52 +245,61 @@ AC_DEFUN([ZFS_AC_KERNEL_SHRINKER_CALLBACK],[
 				dnl #
 				AC_MSG_CHECKING(
 				    [whether ->count_objects callback exists])
-				ZFS_LINUX_TRY_COMPILE([
-					#include <linux/mm.h>
-
-					unsigned long shrinker_cb(
-						struct shrinker *shrink,
-						struct shrink_control *sc) {
-						return 0;
-					}
-				],[
-					struct shrinker cache_shrinker = {
-						.count_objects = shrinker_cb,
-						.scan_objects = shrinker_cb,
-						.seeks = DEFAULT_SEEKS,
-					};
-					register_shrinker(&cache_shrinker);
-				],[
+				ZFS_LINUX_TEST_RESULT(
+				    [shrinker_cb_shrink_control_split], [
 					AC_MSG_RESULT(yes)
 					AC_DEFINE(HAVE_SPLIT_SHRINKER_CALLBACK,
 						1, [->count_objects exists])
 				],[
-					AC_MSG_ERROR(error)
+					ZFS_LINUX_TEST_ERROR([shrinker])
 				])
 			])
 		])
 	])
-	EXTRA_KCFLAGS="$tmp_flags"
 ])
 
 dnl #
 dnl # 2.6.39 API change,
 dnl # Shrinker adjust to use common shrink_control structure.
 dnl #
-AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT], [
-	AC_MSG_CHECKING([whether struct shrink_control exists])
-	ZFS_LINUX_TRY_COMPILE([
+AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_STRUCT], [
+	ZFS_LINUX_TEST_SRC([shrink_control_struct], [
 		#include <linux/mm.h>
 	],[
 		struct shrink_control sc __attribute__ ((unused));
 
 		sc.nr_to_scan = 0;
 		sc.gfp_mask = GFP_KERNEL;
-	],[
+	])
+])
+
+AC_DEFUN([ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT], [
+	AC_MSG_CHECKING([whether struct shrink_control exists])
+	ZFS_LINUX_TEST_RESULT([shrink_control_struct], [
 		AC_MSG_RESULT(yes)
 		AC_DEFINE(HAVE_SHRINK_CONTROL_STRUCT, 1,
-			[struct shrink_control exists])
+		    [struct shrink_control exists])
 	],[
 		AC_MSG_RESULT(no)
 	])
 ])
+
+AC_DEFUN([ZFS_AC_KERNEL_SRC_SHRINKER], [
+	ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_SHRINK
+	ZFS_AC_KERNEL_SRC_SUPER_BLOCK_S_INSTANCES_LIST_HEAD
+	ZFS_AC_KERNEL_SRC_NR_CACHED_OBJECTS
+	ZFS_AC_KERNEL_SRC_FREE_CACHED_OBJECTS
+	ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_HAS_NID
+	ZFS_AC_KERNEL_SRC_SHRINKER_CALLBACK
+	ZFS_AC_KERNEL_SRC_SHRINK_CONTROL_STRUCT
+])
+
+AC_DEFUN([ZFS_AC_KERNEL_SHRINKER], [
+	ZFS_AC_KERNEL_SUPER_BLOCK_S_SHRINK
+	ZFS_AC_KERNEL_SUPER_BLOCK_S_INSTANCES_LIST_HEAD
+	ZFS_AC_KERNEL_NR_CACHED_OBJECTS
+	ZFS_AC_KERNEL_FREE_CACHED_OBJECTS
+	ZFS_AC_KERNEL_SHRINK_CONTROL_HAS_NID
+	ZFS_AC_KERNEL_SHRINKER_CALLBACK
+	ZFS_AC_KERNEL_SHRINK_CONTROL_STRUCT
+])