fstests.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
* [PATCH V2 00/16] Fix locktest and add lease testing to it
@ 2019-09-23 17:51 ira.weiny
  2019-09-23 17:51 ` [PATCH V2 01/16] src/locktest: Remove unnecessary sleep ira.weiny
                   ` (11 more replies)
  0 siblings, 12 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:51 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

Add lease tests[1] to locktest because they share so much code.  Make running
of lease tests separate as an '-L' option.

To make things cleaner update the lock test code and test script.  This
includes fixing a rather serious bug.                                                                                                                 

Finally update the error output to help identify any steps which fail during
testing.                                                                                                                                              

Changes from V1:
	Create a new option '-L' to run lease testing
	Created 568 test script which shared common code with 131
	Moved 2 patches earlier in the series
		[PATCH V2 09/16] src/locktest: Clean up error output
		[PATCH V2 10/16] src/locktest: Audit all debug output
	Added 3 patches
		[PATCH V2 11/16] src/locktest: Add run() function
		[PATCH V2 15/16] common/locktest: Add common locktest functions
		[PATCH V2 16/16] generic/568: Add lease testing

Ira Weiny (16):
  src/locktest: Remove unnecessary sleep
  src/locktest: Remove OPEN macro
  src/locktest: Change command macro names
  src/locktest: Add get_cmd_str
  src/locktest.c: Clean up client command passing
  src/locktest.c: Fix return code if last test fails
  generic/131: Clean up pid variables
  generic/131: Save stderr for debugging
  src/locktest: Clean up error output
  src/locktest: Audit all debug output
  src/locktest: Add run() function
  src/locktest: Add simple lease testing
  src/locktest: Add lease testing for basic signal reception
  src/locktest: Add truncate lease tests
  common/locktest: Add common locktest functions
  generic/568: Add lease testing

 common/locktest       |  95 ++++
 src/locktest.c        | 999 +++++++++++++++++++++++++++---------------
 tests/generic/131     |  54 +--
 tests/generic/568     |  32 ++
 tests/generic/568.out |   2 +
 tests/generic/group   |   1 +
 6 files changed, 786 insertions(+), 397 deletions(-)
 create mode 100644 common/locktest
 create mode 100755 tests/generic/568
 create mode 100644 tests/generic/568.out

-- 
2.20.1

^ permalink raw reply	[flat|nested] 14+ messages in thread

* [PATCH V2 01/16] src/locktest: Remove unnecessary sleep
  2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
@ 2019-09-23 17:51 ` ira.weiny
  2019-09-23 17:51 ` [PATCH V2 02/16] src/locktest: Remove OPEN macro ira.weiny
                   ` (10 subsequent siblings)
  11 siblings, 0 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:51 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

There is no need to sleep because we asked for debugging.  Remove extra
sleep code.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Ira Weiny <ira.weiny@intel.com>
---
 src/locktest.c | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/locktest.c b/src/locktest.c
index 8e27e922668e..29e914febdf9 100644
--- a/src/locktest.c
+++ b/src/locktest.c
@@ -69,7 +69,6 @@ extern int h_errno;
 
 #define RAND()              (rand())
 #define SRAND(s)            (srand(s))
-#define SLEEP(s)            (sleep(s))
 
 #define MIN(A,B)            (((A)<(B))?(A):(B))
 #define MAX(A,B)            (((A)>(B))?(A):(B))
@@ -1037,10 +1036,6 @@ main(int argc, char *argv[])
 		    }
 		}
 	    }
-	    if (debug > 1) {
-		fprintf(stderr, "server sleeping ...\n");
-		SLEEP(1);
-	    }
 	    if(tests[index][TEST_NUM] != 0) {
 		if(last_test != tests[index][TEST_NUM]) {
 		    test_count++;
-- 
2.20.1

^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH V2 02/16] src/locktest: Remove OPEN macro
  2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
  2019-09-23 17:51 ` [PATCH V2 01/16] src/locktest: Remove unnecessary sleep ira.weiny
@ 2019-09-23 17:51 ` ira.weiny
  2019-09-23 17:51 ` [PATCH V2 03/16] src/locktest: Change command macro names ira.weiny
                   ` (9 subsequent siblings)
  11 siblings, 0 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:51 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

The code is much cleaner without this macro.  While here add extra debug
output as well.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Ira Weiny <ira.weiny@intel.com>
---
 src/locktest.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/locktest.c b/src/locktest.c
index 29e914febdf9..b5e1cf7669d8 100644
--- a/src/locktest.c
+++ b/src/locktest.c
@@ -61,7 +61,6 @@ extern int h_errno;
        
 #define HANDLE              int
 #define INVALID_HANDLE      -1
-#define OPEN(N,F)           (open(N, F|O_CREAT|O_BINARY, 0644))
 #define SEEK(H, O)          (lseek(H, O, SEEK_SET))
 #define READ(H, B, L)       (read(H, B, L))
 #define WRITE(H, B, L)      (write(H, B, L))
@@ -598,12 +597,16 @@ initialize(HANDLE fd)
 
 int do_open(int flag)
 {
-    if ((f_fd = OPEN(filename, flag)) == INVALID_HANDLE) {
+    int flags = flag|O_CREAT|O_BINARY;
+
+    if(debug > 1)
+	fprintf(stderr, "do_open %s 0x%x\n", filename, flags);
+
+    if ((f_fd = open(filename, flags, 0666)) == INVALID_HANDLE) {
 	perror("shared file create");
 	return FAIL;
 	/*NOTREACHED*/
     }
-
     return PASS;
 }
 
-- 
2.20.1

^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH V2 03/16] src/locktest: Change command macro names
  2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
  2019-09-23 17:51 ` [PATCH V2 01/16] src/locktest: Remove unnecessary sleep ira.weiny
  2019-09-23 17:51 ` [PATCH V2 02/16] src/locktest: Remove OPEN macro ira.weiny
@ 2019-09-23 17:51 ` ira.weiny
  2019-09-23 17:51 ` [PATCH V2 04/16] src/locktest: Add get_cmd_str ira.weiny
                   ` (8 subsequent siblings)
  11 siblings, 0 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:51 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

The macro names for commands are not consistent.  Change them such that
they are not confused with other flags and macros within the test.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Ira Weiny <ira.weiny@intel.com>
---
 src/locktest.c | 546 ++++++++++++++++++++++++-------------------------
 1 file changed, 273 insertions(+), 273 deletions(-)

diff --git a/src/locktest.c b/src/locktest.c
index b5e1cf7669d8..ce04ecba6205 100644
--- a/src/locktest.c
+++ b/src/locktest.c
@@ -87,13 +87,13 @@ static SOCKET	s_fd = -1;              /* listen socket    */
 static SOCKET	c_fd = -1;	        /* IPC socket       */
 static HANDLE	f_fd = INVALID_HANDLE;	/* shared file      */
 
-#define 	WRLOCK	0
-#define 	RDLOCK	1
-#define		UNLOCK	2
-#define		F_CLOSE	3
-#define		F_OPEN	4
-#define		WRTEST	5
-#define		RDTEST	6
+#define 	CMD_WRLOCK	0
+#define 	CMD_RDLOCK	1
+#define		CMD_UNLOCK	2
+#define		CMD_CLOSE	3
+#define		CMD_OPEN	4
+#define		CMD_WRTEST	5
+#define		CMD_RDTEST	6
 
 #define		PASS 	1
 #define		FAIL	0
@@ -175,361 +175,361 @@ static int64_t tests[][6] =
 	{ 	
 	/* Various simple tests exercising the list */
 
-/* SECTION 1: WRITE and UNLOCK with the same process (SERVER) */
+/* SECTION 1: WRITE and CMD_UNLOCK with the same process (SERVER) */
 	/* Add a lock to an empty list */
-		{1,	WRLOCK,	1,		10,		PASS,		SERVER	}, 
-		{1,	UNLOCK,	1,		10,		PASS,		SERVER	}, 
+		{1,	CMD_WRLOCK,	1,		10,		PASS,		SERVER	}, 
+		{1,	CMD_UNLOCK,	1,		10,		PASS,		SERVER	}, 
 		
 	/* Add a lock to the start and end of a list - 1, 13 - no overlap */
-		{2,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{2,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{2,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
-		{2,	WRLOCK,	1,		5,		PASS,		SERVER	}, 
-		{2,	WRLOCK,	70,		5,		PASS,		SERVER	}, 
+		{2,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{2,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{2,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{2,	CMD_WRLOCK,	1,		5,		PASS,		SERVER	}, 
+		{2,	CMD_WRLOCK,	70,		5,		PASS,		SERVER	}, 
 		
-		{2,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{2,	UNLOCK,	30,		10,		PASS,		SERVER	}, 
-		{2,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
-		{2,	UNLOCK,	1,		5,		PASS,		SERVER	}, 
-		{2,	UNLOCK,	70,		5,		PASS,		SERVER	}, 
+		{2,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{2,	CMD_UNLOCK,	30,		10,		PASS,		SERVER	}, 
+		{2,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{2,	CMD_UNLOCK,	1,		5,		PASS,		SERVER	}, 
+		{2,	CMD_UNLOCK,	70,		5,		PASS,		SERVER	}, 
 		
 	/* Add a lock to the middle of a list - no overlap */
-		{3,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{3,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{3,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
-		{3,	WRLOCK,	42,		5,		PASS,		SERVER	}, 
+		{3,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{3,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{3,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{3,	CMD_WRLOCK,	42,		5,		PASS,		SERVER	}, 
 		
-		{3,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{3,	UNLOCK,	30,		10,		PASS,		SERVER	}, 
-		{3,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
-		{3,	UNLOCK,	42,		5,		PASS,		SERVER	}, 
+		{3,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{3,	CMD_UNLOCK,	30,		10,		PASS,		SERVER	}, 
+		{3,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{3,	CMD_UNLOCK,	42,		5,		PASS,		SERVER	}, 
 		
 	/* Add different lock types to middle of the list - overlap exact match - 3 */
-		{4,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{4,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{4,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{4,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{4,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{4,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* Exact match - same lock type */
-		{4,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{4,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
 		/* Exact match - different lock type */
-		{4,	RDLOCK,	30,		10,		PASS,		SERVER	}, 
+		{4,	CMD_RDLOCK,	30,		10,		PASS,		SERVER	}, 
 		/* Exact match - unlock */
-		{4,	UNLOCK,	30,		10,		PASS,		SERVER	}, 
+		{4,	CMD_UNLOCK,	30,		10,		PASS,		SERVER	}, 
 		/* New lock - as above, inserting in the list again */
-		{4,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{4,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
 		
-		{4,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{4,	UNLOCK,	30,		10,		PASS,		SERVER	}, 
-		{4,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{4,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{4,	CMD_UNLOCK,	30,		10,		PASS,		SERVER	}, 
+		{4,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
 		
 	/* Add new lock which completely overlaps any old lock in the list - 4,5,6 */
-		{5,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{5,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{5,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{5,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{5,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{5,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* The start is the same, end overlaps */
-		{5,	WRLOCK,	30,		15,		PASS,		SERVER	}, 
+		{5,	CMD_WRLOCK,	30,		15,		PASS,		SERVER	}, 
 		/* The start is before, end is the same */
-		{5,	WRLOCK,	25,		20,		PASS,		SERVER	}, 
+		{5,	CMD_WRLOCK,	25,		20,		PASS,		SERVER	}, 
 		/* Both start and end overlap */
-		{5,	WRLOCK,	22,		26,		PASS,		SERVER	}, 
+		{5,	CMD_WRLOCK,	22,		26,		PASS,		SERVER	}, 
 		
-		{5,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{5,	UNLOCK,	22,		26,		PASS,		SERVER	}, 
-		{5,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{5,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{5,	CMD_UNLOCK,	22,		26,		PASS,		SERVER	}, 
+		{5,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
 		
 	/* Add new lock which itself is completely overlaped by any old lock in the list - 7,8,10 */
-		{6,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{6,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{6,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{6,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{6,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{6,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* The start is the same, end is in the middle of old lock - NOP */
-		{6,	WRLOCK,	30,		5,		PASS,		SERVER	}, 
+		{6,	CMD_WRLOCK,	30,		5,		PASS,		SERVER	}, 
 		/* The start and end are in the middle of old lock - NOP */
-		{6,	WRLOCK,	32,		6,		PASS,		SERVER	}, 
+		{6,	CMD_WRLOCK,	32,		6,		PASS,		SERVER	}, 
 		/* Start in the middle and end is the same - NOP */
-		{6,	WRLOCK,	32,		8,		PASS,		SERVER	}, 
+		{6,	CMD_WRLOCK,	32,		8,		PASS,		SERVER	}, 
 		
-		{6,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{6,	UNLOCK,	30,		10,		PASS,		SERVER	}, 
-		{6,	UNLOCK,	32,		8,		PASS,		SERVER	}, 
-		{6,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{6,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{6,	CMD_UNLOCK,	30,		10,		PASS,		SERVER	}, 
+		{6,	CMD_UNLOCK,	32,		8,		PASS,		SERVER	}, 
+		{6,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
 		
 	/* Add new lock which starts before any old lock in the list - 2,9 */
-		{7,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{7,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{7,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{7,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{7,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{7,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* Here is the new lock */
-		{7,	WRLOCK,	27,		10,		PASS,		SERVER	}, 
+		{7,	CMD_WRLOCK,	27,		10,		PASS,		SERVER	}, 
 		/* Go again with the end of the new lock matching the start of old lock */
-		{7,	WRLOCK,	25,		2,		PASS,		SERVER	}, 
+		{7,	CMD_WRLOCK,	25,		2,		PASS,		SERVER	}, 
 		
-		{7,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{7,	UNLOCK,	25,		15,		PASS,		SERVER	}, 
-		{7,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{7,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{7,	CMD_UNLOCK,	25,		15,		PASS,		SERVER	}, 
+		{7,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
 	
 	/* Add new lock which starts in the middle of any old lock in the list and ends after - 11,12 */
-		{8,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{8,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{8,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{8,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{8,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{8,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* Here is the new lock */
-		{8,	WRLOCK,	35,		10,		PASS,		SERVER	}, 
+		{8,	CMD_WRLOCK,	35,		10,		PASS,		SERVER	}, 
 		/* Go again with the end of the new lock matching the start of old lock */
-		{8,	WRLOCK,	45,		2,		PASS,		SERVER	}, 
+		{8,	CMD_WRLOCK,	45,		2,		PASS,		SERVER	}, 
 		
-		{8,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{8,	UNLOCK,	30,		17,		PASS,		SERVER	}, 
-		{8,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
-/* SECTION 2: Overlapping READ and WRITE and UNLOCK with the same process (SERVER) */
+		{8,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{8,	CMD_UNLOCK,	30,		17,		PASS,		SERVER	}, 
+		{8,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
+/* SECTION 2: Overlapping READ and WRITE and CMD_UNLOCK with the same process (SERVER) */
 	/* Add different new lock types which completely overlaps any old lock in the list - 4,5,6 */
-		{9,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{9,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{9,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{9,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{9,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{9,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* The start is the same, end overlaps */
-		{9,	RDLOCK,	30,		15,		PASS,		SERVER	}, 
+		{9,	CMD_RDLOCK,	30,		15,		PASS,		SERVER	}, 
 		/* The start is before, end is the same */
-		{9,	WRLOCK,	25,		20,		PASS,		SERVER	}, 
+		{9,	CMD_WRLOCK,	25,		20,		PASS,		SERVER	}, 
 		/* Both start and end overlap */
-		{9,	RDLOCK,	22,		26,		PASS,		SERVER	}, 
+		{9,	CMD_RDLOCK,	22,		26,		PASS,		SERVER	}, 
 		
-		{9,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{9,	UNLOCK,	22,		26,		PASS,		SERVER	}, 
-		{9,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{9,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{9,	CMD_UNLOCK,	22,		26,		PASS,		SERVER	}, 
+		{9,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
 		
 	/* Add different new locks which are completely overlaped by an old lock in the list - 7,8,10 */
-		{10,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{10,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{10,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{10,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{10,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{10,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* The start is the same, end is in the middle of old lock */
-		{10,	RDLOCK,	30,		5,		PASS,		SERVER	}, 
+		{10,	CMD_RDLOCK,	30,		5,		PASS,		SERVER	}, 
 		/* The start and end are in the middle of a lock */
-		{10,	WRLOCK,	32,		2,		PASS,		SERVER	}, 
+		{10,	CMD_WRLOCK,	32,		2,		PASS,		SERVER	}, 
 		/* Start in the middle and end is the same */
-		{10,	RDLOCK,	36,		5,		PASS,		SERVER	}, 
+		{10,	CMD_RDLOCK,	36,		5,		PASS,		SERVER	}, 
 		
-		{10,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{10,	UNLOCK,	30,		11,		PASS,		SERVER	}, 
-		{10,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{10,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{10,	CMD_UNLOCK,	30,		11,		PASS,		SERVER	}, 
+		{10,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
 		
 	/* Add different new lock types which start before the old lock in the list - 2,9 */
-		{11,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{11,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{11,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{11,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{11,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{11,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* Here is the new lock */
-		{11,	RDLOCK,	27,		10,		PASS,		SERVER	}, 
+		{11,	CMD_RDLOCK,	27,		10,		PASS,		SERVER	}, 
 		/* Go again with the end of the new lock matching the start of lock */
-		{11,	WRLOCK,	25,		3,		PASS,		SERVER	}, 
+		{11,	CMD_WRLOCK,	25,		3,		PASS,		SERVER	}, 
 		
-		{11,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{11,	UNLOCK,	25,		15,		PASS,		SERVER	}, 
-		{11,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{11,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{11,	CMD_UNLOCK,	25,		15,		PASS,		SERVER	}, 
+		{11,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
 	
 	/* Add different new lock types which start in the middle of an old lock in the list and end after - 11,12 */
-		{12,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{12,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{12,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{12,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{12,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{12,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* Here is the new lock */
-		{12,	RDLOCK,	35,		10,		PASS,		SERVER	}, 
+		{12,	CMD_RDLOCK,	35,		10,		PASS,		SERVER	}, 
 		/* Go again with the end of the new lock matching the start of old lock */
-		{12,	WRLOCK,	44,		3,		PASS,		SERVER	}, 
+		{12,	CMD_WRLOCK,	44,		3,		PASS,		SERVER	}, 
 		
-		{12,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{12,	UNLOCK,	30,		18,		PASS,		SERVER	}, 
-		{12,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{12,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{12,	CMD_UNLOCK,	30,		18,		PASS,		SERVER	}, 
+		{12,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
 
-/* SECTION 3: Overlapping READ and WRITE and UNLOCK with the different processes (CLIENT/SERVER) */
+/* SECTION 3: Overlapping READ and WRITE and CMD_UNLOCK with the different processes (CLIENT/SERVER) */
 	/* Add new lock, differing types and processes, to middle of the list - exact overlap match - 3 */
-		{13,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{13,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{13,	RDLOCK,	50,		10,		PASS,		SERVER	}, 
+		{13,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{13,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{13,	CMD_RDLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* Same lock type, different process */
-		{13,	WRLOCK,	30,		10,		FAIL,		CLIENT	}, 
-		{13,	RDLOCK,	50,		10,		PASS,		CLIENT	}, 
+		{13,	CMD_WRLOCK,	30,		10,		FAIL,		CLIENT	}, 
+		{13,	CMD_RDLOCK,	50,		10,		PASS,		CLIENT	}, 
 		/* Exact match - different lock type, different process */
-		{13,	RDLOCK,	30,		10,		FAIL,		CLIENT	}, 
+		{13,	CMD_RDLOCK,	30,		10,		FAIL,		CLIENT	}, 
 		/* Exact match - unlock */
-		{13,	UNLOCK,	30,		10,		PASS,		CLIENT	}, 
+		{13,	CMD_UNLOCK,	30,		10,		PASS,		CLIENT	}, 
 		/* New lock - as above, inserting in the list again */
-		{13,	UNLOCK,	30,		10,		PASS,		SERVER	}, 
+		{13,	CMD_UNLOCK,	30,		10,		PASS,		SERVER	}, 
 		/* Exact match - same lock type, different process */
-		{13,	WRLOCK,	30,		10,		PASS,		CLIENT	}, 
+		{13,	CMD_WRLOCK,	30,		10,		PASS,		CLIENT	}, 
 		
-		{13,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{13,	UNLOCK,	30,		10,		PASS,		CLIENT	}, 
-		{13,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{13,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{13,	CMD_UNLOCK,	30,		10,		PASS,		CLIENT	}, 
+		{13,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
 		
 	/* Add new lock, differing types and processes, which completely overlap any of the locks in the list - 4,5,6 */
-		{14,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{14,	WRLOCK,	30,		10,		PASS,		SERVER	}, 
-		{14,	RDLOCK,	50,		10,		PASS,		SERVER	}, 
+		{14,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{14,	CMD_WRLOCK,	30,		10,		PASS,		SERVER	}, 
+		{14,	CMD_RDLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* The start is the same, end overlaps */
-		{14,	RDLOCK,	30,		15,		FAIL,		CLIENT	},
-		{14,	WRLOCK,	30,		15,		FAIL,		CLIENT	}, 
+		{14,	CMD_RDLOCK,	30,		15,		FAIL,		CLIENT	},
+		{14,	CMD_WRLOCK,	30,		15,		FAIL,		CLIENT	}, 
 		/* The start is before, end is the same */
-		{14,	RDLOCK,	25,		20,		FAIL,		CLIENT	}, 
-		{14,	WRLOCK,	25,		20,		FAIL,		CLIENT	}, 
+		{14,	CMD_RDLOCK,	25,		20,		FAIL,		CLIENT	}, 
+		{14,	CMD_WRLOCK,	25,		20,		FAIL,		CLIENT	}, 
 		/* Both start and end overlap */
-		{14,	RDLOCK,	22,		26,		FAIL,		CLIENT	}, 
-		{14,	WRLOCK,	22,		26,		FAIL,		CLIENT	}, 
+		{14,	CMD_RDLOCK,	22,		26,		FAIL,		CLIENT	}, 
+		{14,	CMD_WRLOCK,	22,		26,		FAIL,		CLIENT	}, 
 		
 		/* The start is the same, end overlaps */
-		{14,	RDLOCK,	50,		15,		PASS,		CLIENT	},
-		{14,	WRLOCK,	50,		17,		FAIL,		CLIENT	}, 
+		{14,	CMD_RDLOCK,	50,		15,		PASS,		CLIENT	},
+		{14,	CMD_WRLOCK,	50,		17,		FAIL,		CLIENT	}, 
 		/* The start is before, end is the same */
-		{14,	RDLOCK,	45,		20,		PASS,		CLIENT	}, 
-		{14,	WRLOCK,	43,		22,		FAIL,		CLIENT	}, 
+		{14,	CMD_RDLOCK,	45,		20,		PASS,		CLIENT	}, 
+		{14,	CMD_WRLOCK,	43,		22,		FAIL,		CLIENT	}, 
 		/* Both start and end overlap */
-		{14,	RDLOCK,	42,		26,		PASS,		CLIENT	}, 
-		{14,	WRLOCK,	41,		28,		FAIL,		CLIENT	}, 
+		{14,	CMD_RDLOCK,	42,		26,		PASS,		CLIENT	}, 
+		{14,	CMD_WRLOCK,	41,		28,		FAIL,		CLIENT	}, 
 		
-		{14,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{14,	UNLOCK,	22,		26,		PASS,		SERVER	}, 
-		{14,	UNLOCK,	42,		26,		PASS,		CLIENT	}, 
+		{14,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{14,	CMD_UNLOCK,	22,		26,		PASS,		SERVER	}, 
+		{14,	CMD_UNLOCK,	42,		26,		PASS,		CLIENT	}, 
 
 	/* Add new lock, differing types and processes, which are completely overlaped by an old lock in the list - 7,8,10 */
-		{15,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{15,	RDLOCK,	30,		10,		PASS,		SERVER	}, 
-		{15,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{15,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{15,	CMD_RDLOCK,	30,		10,		PASS,		SERVER	}, 
+		{15,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* The start is the same, end is in the middle of old lock */
-		{15,	RDLOCK,	50,		5,		FAIL,		CLIENT	}, 
-		{15,	WRLOCK,	50,		5,		FAIL,		CLIENT	}, 
+		{15,	CMD_RDLOCK,	50,		5,		FAIL,		CLIENT	}, 
+		{15,	CMD_WRLOCK,	50,		5,		FAIL,		CLIENT	}, 
 		/* The start and end are in the middle of old lock */
-		{15,	RDLOCK,	52,		6,		FAIL,		CLIENT	}, 
-		{15,	WRLOCK,	52,		6,		FAIL,		CLIENT	}, 
+		{15,	CMD_RDLOCK,	52,		6,		FAIL,		CLIENT	}, 
+		{15,	CMD_WRLOCK,	52,		6,		FAIL,		CLIENT	}, 
 		/* Start in the middle and end is the same */
-		{15,	RDLOCK,	52,		8,		FAIL,		CLIENT	}, 
-		{15,	WRLOCK,	52,		8,		FAIL,		CLIENT	}, 
+		{15,	CMD_RDLOCK,	52,		8,		FAIL,		CLIENT	}, 
+		{15,	CMD_WRLOCK,	52,		8,		FAIL,		CLIENT	}, 
 		/* The start is the same, end is in the middle of old lock */
-		{15,	RDLOCK,	30,		5,		PASS,		CLIENT	}, 
-		{15,	WRLOCK,	30,		5,		FAIL,		CLIENT	}, 
+		{15,	CMD_RDLOCK,	30,		5,		PASS,		CLIENT	}, 
+		{15,	CMD_WRLOCK,	30,		5,		FAIL,		CLIENT	}, 
 		/* The start and end are in the middle of old lock */
-		{15,	RDLOCK,	32,		6,		PASS,		CLIENT	}, 
-		{15,	WRLOCK,	32,		6,		FAIL,		CLIENT	}, 
+		{15,	CMD_RDLOCK,	32,		6,		PASS,		CLIENT	}, 
+		{15,	CMD_WRLOCK,	32,		6,		FAIL,		CLIENT	}, 
 		/* Start in the middle and end is the same */
-		{15,	RDLOCK,	32,		8,		PASS,		CLIENT	}, 
-		{15,	WRLOCK,	32,		8,		FAIL,		CLIENT	}, 
+		{15,	CMD_RDLOCK,	32,		8,		PASS,		CLIENT	}, 
+		{15,	CMD_WRLOCK,	32,		8,		FAIL,		CLIENT	}, 
 		
-		{15,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{15,	UNLOCK,	30,		10,		PASS,		SERVER	}, 
-		{15,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{15,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{15,	CMD_UNLOCK,	30,		10,		PASS,		SERVER	}, 
+		{15,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
 	/* Add new lock, differing types and processes, which start before a lock in the list - 2,9 */
-		{16,	RDLOCK,	10,		10,		PASS,		SERVER	}, 
-		{16,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{16,	CMD_RDLOCK,	10,		10,		PASS,		SERVER	}, 
+		{16,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* Start is before, end is the start of the old lock in list */
-		{16,	RDLOCK,	5,		6,		PASS,		CLIENT	}, 
-		{16,	WRLOCK,	5,		6,		FAIL,		CLIENT	}, 
+		{16,	CMD_RDLOCK,	5,		6,		PASS,		CLIENT	}, 
+		{16,	CMD_WRLOCK,	5,		6,		FAIL,		CLIENT	}, 
 		/* Start is before, end is in the middle of the old lock */
-		{16,	RDLOCK,	5,		10,		PASS,		CLIENT	}, 
-		{16,	WRLOCK,	5,		10,		FAIL,		CLIENT	}, 
+		{16,	CMD_RDLOCK,	5,		10,		PASS,		CLIENT	}, 
+		{16,	CMD_WRLOCK,	5,		10,		FAIL,		CLIENT	}, 
 		/* Start is before, end is the start of the old lock in list */
-		{16,	RDLOCK,	45,		6,		FAIL,		CLIENT	}, 
-		{16,	WRLOCK,	45,		6,		FAIL,		CLIENT	}, 
+		{16,	CMD_RDLOCK,	45,		6,		FAIL,		CLIENT	}, 
+		{16,	CMD_WRLOCK,	45,		6,		FAIL,		CLIENT	}, 
 		/* Start is before, end is in the middle of the old lock */
-		{16,	RDLOCK,	45,		10,		FAIL,		CLIENT	}, 
-		{16,	WRLOCK,	45,		10,		FAIL,		CLIENT	}, 
+		{16,	CMD_RDLOCK,	45,		10,		FAIL,		CLIENT	}, 
+		{16,	CMD_WRLOCK,	45,		10,		FAIL,		CLIENT	}, 
 		
-		{16,	UNLOCK,	5,		15,		PASS,		CLIENT	}, 
-		{16,	UNLOCK,	30,		10,		PASS,		SERVER	}, 
-		{16,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{16,	CMD_UNLOCK,	5,		15,		PASS,		CLIENT	}, 
+		{16,	CMD_UNLOCK,	30,		10,		PASS,		SERVER	}, 
+		{16,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
 
 	/* Add new lock, differing types and processes, which starts in the middle of a lock, and ends after - 11,12 */
-		{17,	WRLOCK,	10,		10,		PASS,		SERVER	}, 
-		{17,	RDLOCK,	30,		10,		PASS,		SERVER	}, 
-		{17,	WRLOCK,	50,		10,		PASS,		SERVER	}, 
+		{17,	CMD_WRLOCK,	10,		10,		PASS,		SERVER	}, 
+		{17,	CMD_RDLOCK,	30,		10,		PASS,		SERVER	}, 
+		{17,	CMD_WRLOCK,	50,		10,		PASS,		SERVER	}, 
 		/* Start in the middle, end after lock in list */
-		{17,	WRLOCK,	35,		10,		FAIL,		CLIENT	}, 
+		{17,	CMD_WRLOCK,	35,		10,		FAIL,		CLIENT	}, 
 		/* Start matches end of lock in list  */
-		{17,	RDLOCK,	35,		10,		PASS,		CLIENT	}, 
-		{17,	RDLOCK,	44,		2,		PASS,		CLIENT	}, 
+		{17,	CMD_RDLOCK,	35,		10,		PASS,		CLIENT	}, 
+		{17,	CMD_RDLOCK,	44,		2,		PASS,		CLIENT	}, 
 		/* Start in the middle, end after lock in list */
-		{17,	RDLOCK,	55,		10,		FAIL,		CLIENT	}, 
-		{17,	WRLOCK,	55,		10,		FAIL,		CLIENT	}, 
+		{17,	CMD_RDLOCK,	55,		10,		FAIL,		CLIENT	}, 
+		{17,	CMD_WRLOCK,	55,		10,		FAIL,		CLIENT	}, 
 		/* Start matches end of lock in list  */
-		{17,	RDLOCK,	59,		5,		FAIL,		CLIENT	}, 
-		{17,	WRLOCK,	59,		5,		FAIL,		CLIENT	}, 
+		{17,	CMD_RDLOCK,	59,		5,		FAIL,		CLIENT	}, 
+		{17,	CMD_WRLOCK,	59,		5,		FAIL,		CLIENT	}, 
 		
-		{17,	UNLOCK,	10,		10,		PASS,		SERVER	}, 
-		{17,	UNLOCK,	30,		16,		PASS,		CLIENT	}, 
-		{17,	UNLOCK,	50,		10,		PASS,		SERVER	}, 
+		{17,	CMD_UNLOCK,	10,		10,		PASS,		SERVER	}, 
+		{17,	CMD_UNLOCK,	30,		16,		PASS,		CLIENT	}, 
+		{17,	CMD_UNLOCK,	50,		10,		PASS,		SERVER	}, 
 
 /* SECTION 4: overlapping and EOF tests */
 	/* Acquire overlapping ranges */
-		{18,	WRLOCK,	11,		7,		PASS,		SERVER	},
-		{18,	WRLOCK,	13,		8,		FAIL,		CLIENT	},
-		{18,	UNLOCK,	11,		7,		PASS,		SERVER	},
+		{18,	CMD_WRLOCK,	11,		7,		PASS,		SERVER	},
+		{18,	CMD_WRLOCK,	13,		8,		FAIL,		CLIENT	},
+		{18,	CMD_UNLOCK,	11,		7,		PASS,		SERVER	},
 	/* Acquire different ranges beyond EOF */
-		{19,	WRLOCK,	10,		FILE_SIZE,	PASS,		SERVER	},
-		{19,	WRLOCK,	FILE_SIZE + 10,	10,		PASS,		CLIENT	},
-		{19,	UNLOCK,	10,		FILE_SIZE,	PASS,		SERVER	},
-		{19,	UNLOCK,	FILE_SIZE + 10,	10,		PASS,		CLIENT	},
+		{19,	CMD_WRLOCK,	10,		FILE_SIZE,	PASS,		SERVER	},
+		{19,	CMD_WRLOCK,	FILE_SIZE + 10,	10,		PASS,		CLIENT	},
+		{19,	CMD_UNLOCK,	10,		FILE_SIZE,	PASS,		SERVER	},
+		{19,	CMD_UNLOCK,	FILE_SIZE + 10,	10,		PASS,		CLIENT	},
 	/* Acquire same range beyong EOF */
-		{20,	WRLOCK,	10,		FILE_SIZE,	PASS,		SERVER,	},
-		{20,	WRLOCK,	10,		FILE_SIZE,	FAIL,		CLIENT,	},
-		{20,	UNLOCK,	10,		FILE_SIZE,	PASS,		SERVER,	},
+		{20,	CMD_WRLOCK,	10,		FILE_SIZE,	PASS,		SERVER,	},
+		{20,	CMD_WRLOCK,	10,		FILE_SIZE,	FAIL,		CLIENT,	},
+		{20,	CMD_UNLOCK,	10,		FILE_SIZE,	PASS,		SERVER,	},
 	/* Acquire whole file lock */
-		{21,	WRLOCK,	0,		0,		PASS,		SERVER,	},
-		{21,	WRLOCK,	0,		0,		FAIL,		CLIENT,	},
-		{21,	UNLOCK,	0,		0,		PASS,		SERVER,	},
+		{21,	CMD_WRLOCK,	0,		0,		PASS,		SERVER,	},
+		{21,	CMD_WRLOCK,	0,		0,		FAIL,		CLIENT,	},
+		{21,	CMD_UNLOCK,	0,		0,		PASS,		SERVER,	},
 	/* Acquire whole file lock, then range */
-		{22,	WRLOCK,	0,		0,		PASS,		SERVER,	},
-		{22,	WRLOCK,	1,		5,		FAIL,		CLIENT,	},
-		{22,	UNLOCK,	0,		0,		PASS,		SERVER,	},
+		{22,	CMD_WRLOCK,	0,		0,		PASS,		SERVER,	},
+		{22,	CMD_WRLOCK,	1,		5,		FAIL,		CLIENT,	},
+		{22,	CMD_UNLOCK,	0,		0,		PASS,		SERVER,	},
 	/* Acquire non-overlapping read locks */
-		{23,	RDLOCK, 1,		5,		PASS,		SERVER, },
-		{23,	RDLOCK, 7,		6,		PASS,		CLIENT, },
-		{23,	UNLOCK, 1, 		5,		PASS,		SERVER, },
-		{23,	UNLOCK, 7,		6,		PASS,		CLIENT, },
+		{23,	CMD_RDLOCK, 1,		5,		PASS,		SERVER, },
+		{23,	CMD_RDLOCK, 7,		6,		PASS,		CLIENT, },
+		{23,	CMD_UNLOCK, 1, 		5,		PASS,		SERVER, },
+		{23,	CMD_UNLOCK, 7,		6,		PASS,		CLIENT, },
 	/* Acquire overlapping read locks */
-		{24,	RDLOCK, 1,		5,		PASS,		SERVER, },
-		{24,	RDLOCK, 2,		6,		PASS,		CLIENT, },
-		{24,	UNLOCK, 1, 		5,		PASS,		SERVER, },
-		{24,	UNLOCK, 1,		7,		PASS,		CLIENT, },
+		{24,	CMD_RDLOCK, 1,		5,		PASS,		SERVER, },
+		{24,	CMD_RDLOCK, 2,		6,		PASS,		CLIENT, },
+		{24,	CMD_UNLOCK, 1, 		5,		PASS,		SERVER, },
+		{24,	CMD_UNLOCK, 1,		7,		PASS,		CLIENT, },
 	/* Acquire non-overlapping read and write locks */
-		{25,	RDLOCK, 1,		5,		PASS,		SERVER, },
-		{25,	WRLOCK, 7,		6,		PASS,		CLIENT, },
-		{25,	UNLOCK, 1, 		5,		PASS,		SERVER, },
-		{25,	UNLOCK, 7,		6,		PASS,		CLIENT, },
+		{25,	CMD_RDLOCK, 1,		5,		PASS,		SERVER, },
+		{25,	CMD_WRLOCK, 7,		6,		PASS,		CLIENT, },
+		{25,	CMD_UNLOCK, 1, 		5,		PASS,		SERVER, },
+		{25,	CMD_UNLOCK, 7,		6,		PASS,		CLIENT, },
 	/* Acquire overlapping read and write locks */
-		{26,	RDLOCK, 1,		5,		PASS,		SERVER, },
-		{26,	WRLOCK, 2,		6,		FAIL,		CLIENT, },
-		{26,	UNLOCK, 1, 		5,		PASS,		SERVER, },
+		{26,	CMD_RDLOCK, 1,		5,		PASS,		SERVER, },
+		{26,	CMD_WRLOCK, 2,		6,		FAIL,		CLIENT, },
+		{26,	CMD_UNLOCK, 1, 		5,		PASS,		SERVER, },
 	/* Acquire whole file lock, then close (without unlocking) */
-		{27,	WRLOCK,	0,		0,		PASS,		SERVER,	},
-		{27,	WRLOCK,	1,		5,		FAIL,		CLIENT,	},
-		{27,	F_CLOSE,0,		0,		PASS,		SERVER,	},
-		{27,	WRLOCK,	1,		5,		PASS,		CLIENT,	},
-		{27,	F_OPEN,	O_RDWR,		0,		PASS,		SERVER,	},
-		{27,	UNLOCK,	1,		5,		PASS,		CLIENT,	},
+		{27,	CMD_WRLOCK,	0,		0,		PASS,		SERVER,	},
+		{27,	CMD_WRLOCK,	1,		5,		FAIL,		CLIENT,	},
+		{27,	CMD_CLOSE,0,		0,		PASS,		SERVER,	},
+		{27,	CMD_WRLOCK,	1,		5,		PASS,		CLIENT,	},
+		{27,	CMD_OPEN,	O_RDWR,		0,		PASS,		SERVER,	},
+		{27,	CMD_UNLOCK,	1,		5,		PASS,		CLIENT,	},
 	/* Acquire two read locks, close one file and then reopen to check that first lock still exists */
-		{28,	RDLOCK,	1,		5,		PASS,		SERVER,	},
-		{28,	RDLOCK,	1,		5,		PASS,		CLIENT,	},
-		{28,	F_CLOSE,0,		0,		PASS,		SERVER,	},
-		{28,	F_OPEN,	O_RDWR,		0,		PASS,		SERVER,	},
-		{28,	WRLOCK,	0,		0,		FAIL,		SERVER,	},
-		{28,	UNLOCK,	1,		5,		PASS,		SERVER,	},
+		{28,	CMD_RDLOCK,	1,		5,		PASS,		SERVER,	},
+		{28,	CMD_RDLOCK,	1,		5,		PASS,		CLIENT,	},
+		{28,	CMD_CLOSE,0,		0,		PASS,		SERVER,	},
+		{28,	CMD_OPEN,	O_RDWR,		0,		PASS,		SERVER,	},
+		{28,	CMD_WRLOCK,	0,		0,		FAIL,		SERVER,	},
+		{28,	CMD_UNLOCK,	1,		5,		PASS,		SERVER,	},
 	/* Verify that F_GETLK for F_WRLCK doesn't require that file be opened for write */
-		{29,	F_CLOSE, 0,		0,		PASS,		SERVER, },
-		{29,	F_OPEN, O_RDONLY,	0,		PASS,		SERVER, },
-		{29,	WRTEST, 0,		0,		PASS,		SERVER, },
-		{29,	F_CLOSE,0,		0,		PASS,		SERVER,	},
-		{29,	F_OPEN,	O_RDWR,		0,		PASS,		SERVER,	},
+		{29,	CMD_CLOSE, 0,		0,		PASS,		SERVER, },
+		{29,	CMD_OPEN, O_RDONLY,	0,		PASS,		SERVER, },
+		{29,	CMD_WRTEST, 0,		0,		PASS,		SERVER, },
+		{29,	CMD_CLOSE,0,		0,		PASS,		SERVER,	},
+		{29,	CMD_OPEN,	O_RDWR,		0,		PASS,		SERVER,	},
 #ifdef macosx
 	/* Close the opened file and open the file with SHLOCK, other client will try to open with SHLOCK too */
-		{30,	F_CLOSE,0,		0,		PASS,		SERVER,	},
-		{30,	F_OPEN,	O_RDWR|O_SHLOCK|O_NONBLOCK,	0,	PASS,		SERVER,	},
-		{30,	F_CLOSE,0,		0,		PASS,		CLIENT,	},
-		{30,	F_OPEN,	O_RDWR|O_SHLOCK|O_NONBLOCK,	0,	PASS,		CLIENT,	},
+		{30,	CMD_CLOSE,0,		0,		PASS,		SERVER,	},
+		{30,	CMD_OPEN,	O_RDWR|O_SHLOCK|O_NONBLOCK,	0,	PASS,		SERVER,	},
+		{30,	CMD_CLOSE,0,		0,		PASS,		CLIENT,	},
+		{30,	CMD_OPEN,	O_RDWR|O_SHLOCK|O_NONBLOCK,	0,	PASS,		CLIENT,	},
 	/* Close the opened file and open the file with SHLOCK, other client will try to open with EXLOCK */
-		{31,	F_CLOSE,0,		0,		PASS,		SERVER,	},
-		{31,	F_CLOSE,0,		0,		PASS,		CLIENT,	},
-		{31,	F_OPEN,	O_RDWR|O_SHLOCK|O_NONBLOCK,	0,	PASS,		SERVER,	},
-		{31,	F_OPEN,	O_RDWR|O_EXLOCK|O_NONBLOCK,	0,	FAIL,		CLIENT,	},
+		{31,	CMD_CLOSE,0,		0,		PASS,		SERVER,	},
+		{31,	CMD_CLOSE,0,		0,		PASS,		CLIENT,	},
+		{31,	CMD_OPEN,	O_RDWR|O_SHLOCK|O_NONBLOCK,	0,	PASS,		SERVER,	},
+		{31,	CMD_OPEN,	O_RDWR|O_EXLOCK|O_NONBLOCK,	0,	FAIL,		CLIENT,	},
 	/* Close the opened file and open the file with EXLOCK, other client will try to open with EXLOCK too */
-		{32,	F_CLOSE,0,		0,		PASS,		SERVER,	},
-		{32,	F_CLOSE,0,		0,		FAIL,		CLIENT,	},
-		{32,	F_OPEN,	O_RDWR|O_EXLOCK|O_NONBLOCK,	0,	PASS,		SERVER,	},
-		{32,	F_OPEN,	O_RDWR|O_EXLOCK|O_NONBLOCK,	0,	FAIL,		CLIENT,	},
-		{32,	F_CLOSE,0,		0,		PASS,		SERVER,	},
-		{32,	F_CLOSE,0,		0,		FAIL,		CLIENT,	},
-		{32,	F_OPEN,	O_RDWR,		0,		PASS,		SERVER,	},
-		{32,	F_OPEN,	O_RDWR,		0,		PASS,		CLIENT,	},
+		{32,	CMD_CLOSE,0,		0,		PASS,		SERVER,	},
+		{32,	CMD_CLOSE,0,		0,		FAIL,		CLIENT,	},
+		{32,	CMD_OPEN,	O_RDWR|O_EXLOCK|O_NONBLOCK,	0,	PASS,		SERVER,	},
+		{32,	CMD_OPEN,	O_RDWR|O_EXLOCK|O_NONBLOCK,	0,	FAIL,		CLIENT,	},
+		{32,	CMD_CLOSE,0,		0,		PASS,		SERVER,	},
+		{32,	CMD_CLOSE,0,		0,		FAIL,		CLIENT,	},
+		{32,	CMD_OPEN,	O_RDWR,		0,		PASS,		SERVER,	},
+		{32,	CMD_OPEN,	O_RDWR,		0,		PASS,		CLIENT,	},
 #endif /* macosx */
 	/* indicate end of array */
 		{0,0,0,0,0,SERVER},
@@ -962,25 +962,25 @@ main(int argc, char *argv[])
 
 		if(tests[index][TEST_NUM] != 0) {
 		    switch(tests[index][COMMAND]) {
-			case WRLOCK:
+			case CMD_WRLOCK:
 			    result = do_lock(F_SETLK, F_WRLCK, tests[index][OFFSET], tests[index][LENGTH]);
 			    break;
-			case RDLOCK:
+			case CMD_RDLOCK:
 			    result = do_lock(F_SETLK, F_RDLCK, tests[index][OFFSET], tests[index][LENGTH]);
 			    break;
-			case UNLOCK:
+			case CMD_UNLOCK:
 			    result = do_lock(F_SETLK, F_UNLCK, tests[index][OFFSET], tests[index][LENGTH]);
 			    break;
-			case F_CLOSE:
+			case CMD_CLOSE:
 			    result = do_close();
 			    break;
-			case F_OPEN:
+			case CMD_OPEN:
 			    result = do_open(tests[index][FLAGS]);
 			    break;
-			case WRTEST:
+			case CMD_WRTEST:
 			    result = do_lock(F_GETLK, F_WRLCK, tests[index][OFFSET], tests[index][LENGTH]);
 			    break;
-			case RDTEST:
+			case CMD_RDTEST:
 			    result = do_lock(F_GETLK, F_RDLCK, tests[index][OFFSET], tests[index][LENGTH]);
 			    break;
 		    }
@@ -989,10 +989,10 @@ main(int argc, char *argv[])
 			/* We have a failure */
 			if(debug)
 			    fprintf(stderr, "Server failure in test %d, while %sing using offset %lld, length %lld - err = %d:%s\n", 
-					ctl.test, tests[index][COMMAND]==WRLOCK?"write lock":
-						tests[index][COMMAND]==RDLOCK?"read lock":
-						tests[index][COMMAND]==UNLOCK?"unlock":
-						tests[index][COMMAND]==F_OPEN?"open":"clos", 
+					ctl.test, tests[index][COMMAND]==CMD_WRLOCK?"write lock":
+						tests[index][COMMAND]==CMD_RDLOCK?"read lock":
+						tests[index][COMMAND]==CMD_UNLOCK?"unlock":
+						tests[index][COMMAND]==CMD_OPEN?"open":"clos", 
 						(long long)tests[index][OFFSET],
 						(long long)tests[index][LENGTH],
 						saved_errno, strerror(saved_errno));
@@ -1009,10 +1009,10 @@ main(int argc, char *argv[])
 		} 
 		if(debug > 1)
 		    fprintf(stderr, "Sending command to client (%d) - %s - %lld:%lld\n", 
-					index, tests[index][COMMAND]==WRLOCK?"write lock":
-					tests[index][COMMAND]==RDLOCK?"read lock":
-					tests[index][COMMAND]==UNLOCK?"unlock": 
-					tests[index][COMMAND]==F_OPEN?"open":"clos", 
+					index, tests[index][COMMAND]==CMD_WRLOCK?"write lock":
+					tests[index][COMMAND]==CMD_RDLOCK?"read lock":
+					tests[index][COMMAND]==CMD_UNLOCK?"unlock": 
+					tests[index][COMMAND]==CMD_OPEN?"open":"clos", 
 					(long long)tests[index][OFFSET],
 					(long long)tests[index][LENGTH]);
 		/* get the client to do something */
@@ -1027,10 +1027,10 @@ main(int argc, char *argv[])
 			fail_flag++;
 			if(debug)
 			    fprintf(stderr, "Client failure in test %d, while %sing using offset %lld, length %lld - err = %d:%s\n",
-					ctl.test, ctl.command==WRLOCK?"write lock":
-					ctl.command==RDLOCK?"read lock":
-					ctl.command==UNLOCK?"unlock":
-					ctl.command==F_OPEN?"open":"clos",
+					ctl.test, ctl.command==CMD_WRLOCK?"write lock":
+					ctl.command==CMD_RDLOCK?"read lock":
+					ctl.command==CMD_UNLOCK?"unlock":
+					ctl.command==CMD_OPEN?"open":"clos",
 					(long long)ctl.offset, (long long)ctl.length,
 					ctl.error, strerror(ctl.error));
 			fprintf(stderr, "Client failure in %lld:%s\n",
@@ -1074,25 +1074,25 @@ main(int argc, char *argv[])
 	    ctl.offset = tests[index][OFFSET];
 	    ctl.length = tests[index][LENGTH];
 	    switch(tests[index][COMMAND]) {
-		case WRLOCK:
+		case CMD_WRLOCK:
 		    result = do_lock(F_SETLK, F_WRLCK, tests[index][OFFSET], tests[index][LENGTH]);
 		    break;
-		case RDLOCK:
+		case CMD_RDLOCK:
 		    result = do_lock(F_SETLK, F_RDLCK, tests[index][OFFSET], tests[index][LENGTH]);
 		    break;
-		case UNLOCK:
+		case CMD_UNLOCK:
 		    result = do_lock(F_SETLK, F_UNLCK, tests[index][OFFSET], tests[index][LENGTH]);
 		    break;
-		case F_CLOSE:
+		case CMD_CLOSE:
 		    result = do_close();
 		    break;
-		case F_OPEN:
+		case CMD_OPEN:
 		    result = do_open(tests[index][FLAGS]);
 		    break;
-		case WRTEST:
+		case CMD_WRTEST:
 		    result = do_lock(F_GETLK, F_WRLCK, tests[index][OFFSET], tests[index][LENGTH]);
 		    break;
-		case RDTEST:
+		case CMD_RDTEST:
 		    result = do_lock(F_GETLK, F_RDLCK, tests[index][OFFSET], tests[index][LENGTH]);
 		    break;
 	    }
-- 
2.20.1

^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH V2 04/16] src/locktest: Add get_cmd_str
  2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
                   ` (2 preceding siblings ...)
  2019-09-23 17:51 ` [PATCH V2 03/16] src/locktest: Change command macro names ira.weiny
@ 2019-09-23 17:51 ` ira.weiny
  2019-09-23 17:51 ` [PATCH V2 05/16] src/locktest.c: Clean up client command passing ira.weiny
                   ` (7 subsequent siblings)
  11 siblings, 0 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:51 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

Rather than open code printing the strings, use a helper function.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Ira Weiny <ira.weiny@intel.com>
---
 src/locktest.c | 30 ++++++++++++++++++------------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/locktest.c b/src/locktest.c
index ce04ecba6205..825d9df3ddf8 100644
--- a/src/locktest.c
+++ b/src/locktest.c
@@ -109,6 +109,19 @@ static HANDLE	f_fd = INVALID_HANDLE;	/* shared file      */
 #define		WHO		5
 #define		FLAGS		2 /* index 2 is also used for do_open() flag, see below */
 
+static char *get_cmd_str(int cmd)
+{
+	switch (cmd) {
+		case CMD_WRLOCK: return "write lock"; break;
+		case CMD_RDLOCK: return "read lock"; break;
+		case CMD_UNLOCK: return "unlock"; break;
+		case CMD_CLOSE:  return "close"; break;
+		case CMD_OPEN:   return "open"; break;
+		case CMD_WRTEST: return "Wait for SIGIO"; break;
+		case CMD_RDTEST: return "Truncate"; break;
+	}
+	return "unknown";
+}
 /* 
  * flags for Mac OS X do_open() 
  * O_RDONLY	0x0000
@@ -989,10 +1002,8 @@ main(int argc, char *argv[])
 			/* We have a failure */
 			if(debug)
 			    fprintf(stderr, "Server failure in test %d, while %sing using offset %lld, length %lld - err = %d:%s\n", 
-					ctl.test, tests[index][COMMAND]==CMD_WRLOCK?"write lock":
-						tests[index][COMMAND]==CMD_RDLOCK?"read lock":
-						tests[index][COMMAND]==CMD_UNLOCK?"unlock":
-						tests[index][COMMAND]==CMD_OPEN?"open":"clos", 
+					ctl.test,
+					get_cmd_str(tests[index][COMMAND]),
 						(long long)tests[index][OFFSET],
 						(long long)tests[index][LENGTH],
 						saved_errno, strerror(saved_errno));
@@ -1009,10 +1020,8 @@ main(int argc, char *argv[])
 		} 
 		if(debug > 1)
 		    fprintf(stderr, "Sending command to client (%d) - %s - %lld:%lld\n", 
-					index, tests[index][COMMAND]==CMD_WRLOCK?"write lock":
-					tests[index][COMMAND]==CMD_RDLOCK?"read lock":
-					tests[index][COMMAND]==CMD_UNLOCK?"unlock": 
-					tests[index][COMMAND]==CMD_OPEN?"open":"clos", 
+					index,
+					get_cmd_str(ctl.command),
 					(long long)tests[index][OFFSET],
 					(long long)tests[index][LENGTH]);
 		/* get the client to do something */
@@ -1027,10 +1036,7 @@ main(int argc, char *argv[])
 			fail_flag++;
 			if(debug)
 			    fprintf(stderr, "Client failure in test %d, while %sing using offset %lld, length %lld - err = %d:%s\n",
-					ctl.test, ctl.command==CMD_WRLOCK?"write lock":
-					ctl.command==CMD_RDLOCK?"read lock":
-					ctl.command==CMD_UNLOCK?"unlock":
-					ctl.command==CMD_OPEN?"open":"clos",
+					ctl.test, get_cmd_str(ctl.command),
 					(long long)ctl.offset, (long long)ctl.length,
 					ctl.error, strerror(ctl.error));
 			fprintf(stderr, "Client failure in %lld:%s\n",
-- 
2.20.1

^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH V2 05/16] src/locktest.c: Clean up client command passing
  2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
                   ` (3 preceding siblings ...)
  2019-09-23 17:51 ` [PATCH V2 04/16] src/locktest: Add get_cmd_str ira.weiny
@ 2019-09-23 17:51 ` ira.weiny
  2019-09-23 17:51 ` [PATCH V2 06/16] src/locktest.c: Fix return code if last test fails ira.weiny
                   ` (6 subsequent siblings)
  11 siblings, 0 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:51 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

The client was using the test index rather than the values being passed
to it for a command.  While this technically worked it is cleaner to
fully initialize the command message and use the values in that message.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Ira Weiny <ira.weiny@intel.com>
---
 src/locktest.c | 36 +++++++++++++++++++++++-------------
 1 file changed, 23 insertions(+), 13 deletions(-)

diff --git a/src/locktest.c b/src/locktest.c
index 825d9df3ddf8..3abb91120144 100644
--- a/src/locktest.c
+++ b/src/locktest.c
@@ -670,6 +670,17 @@ int do_close(void)
     return PASS;
 }
 
+static void init_ctl(int32_t index)
+{
+    ctl.test= (int32_t)tests[index][TEST_NUM];
+    ctl.command = (int32_t)tests[index][COMMAND];
+    ctl.offset = tests[index][OFFSET];
+    ctl.length = tests[index][LENGTH];
+    ctl.index = index;
+    ctl.result = (int32_t)tests[index][RESULT];
+    ctl.error = 0;
+}
+
 void
 send_ctl(void)
 {
@@ -1018,6 +1029,8 @@ main(int argc, char *argv[])
 		    ctl.test = 0;
 		    end=1;
 		} 
+		/* get the client to do something */
+		init_ctl(index);
 		if(debug > 1)
 		    fprintf(stderr, "Sending command to client (%d) - %s - %lld:%lld\n", 
 					index,
@@ -1074,20 +1087,16 @@ main(int argc, char *argv[])
 		end = 1;
 		break;
 	    }
-		
 
-	    ctl.command = tests[index][COMMAND];
-	    ctl.offset = tests[index][OFFSET];
-	    ctl.length = tests[index][LENGTH];
-	    switch(tests[index][COMMAND]) {
+	    switch(ctl.command) {
 		case CMD_WRLOCK:
-		    result = do_lock(F_SETLK, F_WRLCK, tests[index][OFFSET], tests[index][LENGTH]);
+		    result = do_lock(F_SETLK, F_WRLCK, ctl.offset, ctl.length);
 		    break;
 		case CMD_RDLOCK:
-		    result = do_lock(F_SETLK, F_RDLCK, tests[index][OFFSET], tests[index][LENGTH]);
+		    result = do_lock(F_SETLK, F_RDLCK, ctl.offset, ctl.length);
 		    break;
 		case CMD_UNLOCK:
-		    result = do_lock(F_SETLK, F_UNLCK, tests[index][OFFSET], tests[index][LENGTH]);
+		    result = do_lock(F_SETLK, F_UNLCK, ctl.offset, ctl.length);
 		    break;
 		case CMD_CLOSE:
 		    result = do_close();
@@ -1096,21 +1105,22 @@ main(int argc, char *argv[])
 		    result = do_open(tests[index][FLAGS]);
 		    break;
 		case CMD_WRTEST:
-		    result = do_lock(F_GETLK, F_WRLCK, tests[index][OFFSET], tests[index][LENGTH]);
+		    result = do_lock(F_GETLK, F_WRLCK, ctl.offset, ctl.length);
 		    break;
 		case CMD_RDTEST:
-		    result = do_lock(F_GETLK, F_RDLCK, tests[index][OFFSET], tests[index][LENGTH]);
+		    result = do_lock(F_GETLK, F_RDLCK, ctl.offset, ctl.length);
 		    break;
 	    }
-	    if( result != tests[index][RESULT] ) {
+	    if( result != ctl.result ) {
 		if(debug)
-		    fprintf(stderr,"Got %d, wanted %lld\n", result,
-					(long long)tests[index][RESULT]);
+		    fprintf(stderr,"Got %d, wanted %d\n",
+				result, ctl.result);
 		ctl.result = FAIL;
 		ctl.error = saved_errno;
 		fail_count++;
 	    } else {
 		ctl.result = PASS;
+		ctl.error = 0;
 	    }
 	    if(debug > 2)
 		fprintf(stderr,"client: sending result to server (%d)\n", ctl.index);
-- 
2.20.1

^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH V2 06/16] src/locktest.c: Fix return code if last test fails
  2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
                   ` (4 preceding siblings ...)
  2019-09-23 17:51 ` [PATCH V2 05/16] src/locktest.c: Clean up client command passing ira.weiny
@ 2019-09-23 17:51 ` ira.weiny
  2019-09-23 17:51 ` [PATCH V2 07/16] generic/131: Clean up pid variables ira.weiny
                   ` (5 subsequent siblings)
  11 siblings, 0 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:51 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

If anything but the first step of the last test fails, the exit code
(fail_count) was not properly set.  Fix this such that follow on patches
will be able to save error output and correctly inform the script that a
failure has occurred rather than just expecting random output to fail
the diff check.

The issue is last_test is not properly tracking which test the loop is
currently on.  Therefore fail_count would not be incremented correctly.

Remove the special case of checking for the end of the steps array and
track last_test properly.  Then adjust test_count to be correct for the
new code.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Ira Weiny <ira.weiny@intel.com>
---
 src/locktest.c | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/src/locktest.c b/src/locktest.c
index 3abb91120144..241e7c451724 100644
--- a/src/locktest.c
+++ b/src/locktest.c
@@ -963,7 +963,7 @@ main(int argc, char *argv[])
     int end = 0;
     int result = 0;
     int last_test = 0;
-    int test_count = 0;
+    int test_count = -1;
     int fail_flag = 0;
     while(!end) {
 	if (server) {
@@ -1058,15 +1058,13 @@ main(int argc, char *argv[])
 		    }
 		}
 	    }
-	    if(tests[index][TEST_NUM] != 0) {
-		if(last_test != tests[index][TEST_NUM]) {
-		    test_count++;
-		    if(fail_flag)
-			fail_count++;
-		    fail_flag = 0;
 
-		}
-		last_test = tests[index][TEST_NUM];
+	    if(last_test != tests[index][TEST_NUM]) {
+	        test_count++;
+	        if(fail_flag)
+		    fail_count++;
+	        fail_flag = 0;
+	        last_test = tests[index][TEST_NUM];
 	    }
 		
 	    index++;
@@ -1126,9 +1124,8 @@ main(int argc, char *argv[])
 		fprintf(stderr,"client: sending result to server (%d)\n", ctl.index);
 	    /* Send result to the server */
 	    send_ctl();
-	    if(tests[index][TEST_NUM] != 0) {
-		if(last_test != tests[index][TEST_NUM])
-		    test_count++;
+	    if(last_test != tests[index][TEST_NUM]) {
+		test_count++;
 		last_test = tests[index][TEST_NUM];
 	    }
 	}
-- 
2.20.1

^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH V2 07/16] generic/131: Clean up pid variables
  2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
                   ` (5 preceding siblings ...)
  2019-09-23 17:51 ` [PATCH V2 06/16] src/locktest.c: Fix return code if last test fails ira.weiny
@ 2019-09-23 17:51 ` ira.weiny
  2019-09-23 17:51 ` [PATCH V2 08/16] generic/131: Save stderr for debugging ira.weiny
                   ` (4 subsequent siblings)
  11 siblings, 0 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:51 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

Change the name of the variables to reflect the client vs server.  This
will help in future patches.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Ira Weiny <ira.weiny@intel.com>
---
 tests/generic/131 | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/generic/131 b/tests/generic/131
index e8cdd48e8667..c333e676e8f9 100755
--- a/tests/generic/131
+++ b/tests/generic/131
@@ -17,8 +17,8 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _cleanup()
 {
-    kill $locktest_pid2 > /dev/null 2>&1
-    kill $locktest_pid1 > /dev/null 2>&1
+	kill $client_pid > /dev/null 2>&1
+	kill $server_pid > /dev/null 2>&1
 }
 
 # get standard environment, filters and checks
@@ -38,7 +38,7 @@ touch $TEST_DIR/server.out
 
 # Start the server
 src/locktest $TESTFILE 2>&1 > $TEST_DIR/server.out &
-locktest_pid1=$!
+server_pid=$!
 
 timeout=30
 while [ $timeout -gt 0 ]; do
@@ -50,7 +50,7 @@ while [ $timeout -gt 0 ]; do
 	fi
 
 	# check the existence of server process
-	if ! kill -s 0 $locktest_pid1 >/dev/null 2>&1; then
+	if ! kill -s 0 $server_pid >/dev/null 2>&1; then
 		echo "Server died abnormally"
 		exit 1
 	fi
@@ -65,7 +65,7 @@ fi
 
 # Start the client
 src/locktest -p $PORT -h localhost $TESTFILE 2>&1 > $TEST_DIR/client.out
-locktest_pid2=$!
+client_pid=$!
 result=$?
 if [ $result -eq 0 ]; then
 	echo success!
-- 
2.20.1

^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH V2 08/16] generic/131: Save stderr for debugging
  2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
                   ` (6 preceding siblings ...)
  2019-09-23 17:51 ` [PATCH V2 07/16] generic/131: Clean up pid variables ira.weiny
@ 2019-09-23 17:51 ` ira.weiny
  2019-09-23 17:51 ` [PATCH V2 09/16] src/locktest: Clean up error output ira.weiny
                   ` (3 subsequent siblings)
  11 siblings, 0 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:51 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

Details of which internal step failed within a test are lost without
additional debugging output.  Save that output by separating stdout and
stderr.

This allows the server port to be written solely to stdout for
consumption by the script.  Then all error output can be sent to the
seqres.full file in the event of a failure.  Then, depend on the return
code of the server _and_ the client to detect failure and save the error
output for inspection.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Ira Weiny <ira.weiny@intel.com>
---
 tests/generic/131 | 63 +++++++++++++++++++++++++++++++++--------------
 1 file changed, 45 insertions(+), 18 deletions(-)

diff --git a/tests/generic/131 b/tests/generic/131
index c333e676e8f9..4d90411d4a19 100755
--- a/tests/generic/131
+++ b/tests/generic/131
@@ -14,11 +14,15 @@ here=`pwd`
 tmp=/tmp/$$
 status=1	# failure is the default!
 trap "_cleanup; exit \$status" 0 1 2 3 15
+debug="-d"
+
+TESTFILE=$TEST_DIR/lock_file
 
 _cleanup()
 {
 	kill $client_pid > /dev/null 2>&1
 	kill $server_pid > /dev/null 2>&1
+	rm -f $TESTFILE
 }
 
 # get standard environment, filters and checks
@@ -31,48 +35,71 @@ _supported_os Linux
 _require_test
 _require_test_fcntl_advisory_locks
 
-TESTFILE=$TEST_DIR/lock_file
+# set up log files
+SERVER_LOG=$TEST_DIR/server.out
+rm -f $SERVER_LOG
+touch $SERVER_LOG
+SERVER_PORT=$TEST_DIR/server.port
+rm -f $SERVER_PORT
+touch $SERVER_PORT
+CLIENT_LOG=$TEST_DIR/client.out
+rm -f $CLIENT_LOG
+touch $CLIENT_LOG
+
+touch $TESTFILE
+
+function dump_logs_fail()
+{
+	fail_str=$1
 
-rm -f $TEST_DIR/server.out
-touch $TEST_DIR/server.out
+	echo "     ***** Client log *****" >> $seqres.full
+	cat $CLIENT_LOG >> $seqres.full
+	echo "     ***** Server log *****" >> $seqres.full
+	cat $SERVER_LOG >> $seqres.full
+	echo "     ***** End file details *****" >> $seqres.full
+	ls -la $TESTFILE >> $seqres.full
+	_fail $fail_str
+	exit 1
+}
 
 # Start the server
-src/locktest $TESTFILE 2>&1 > $TEST_DIR/server.out &
+src/locktest $debug $TESTFILE 2> $SERVER_LOG 1> $SERVER_PORT &
 server_pid=$!
 
 timeout=30
 while [ $timeout -gt 0 ]; do
 	sleep 1
 
-	PORT=$(cat $TEST_DIR/server.out | grep "^server port: " | awk '{print $3}')
+	PORT=$(cat $SERVER_PORT | grep "^server port: " | awk '{print $3}')
 	if [ -n "$PORT" ]; then
 		break
 	fi
 
 	# check the existence of server process
 	if ! kill -s 0 $server_pid >/dev/null 2>&1; then
-		echo "Server died abnormally"
-		exit 1
+		dump_logs_fail "Server died abnormally"
 	fi
 
 	let timeout=timeout-1
 done
 
 if [ -z "$PORT" ]; then
-	echo "Could not get server port"
-	exit 1
+	dump_logs_fail "Could not get server port"
 fi
 
 # Start the client
-src/locktest -p $PORT -h localhost $TESTFILE 2>&1 > $TEST_DIR/client.out
+
+src/locktest $debug -p $PORT -h localhost $TESTFILE 2> $CLIENT_LOG
+client_result=$?
 client_pid=$!
-result=$?
-if [ $result -eq 0 ]; then
-	echo success!
-	status=0
-else
-	echo "Client reported failure ($result)"
-	cat $TEST_DIR/*.out
+if [ $client_result -ne 0 ]; then
+	dump_logs_fail "Client reported failure ($client_result)"
 fi
-
+wait $server_pid
+server_result=$?
+if [ $server_result -ne 0 ]; then
+	dump_logs_fail "Server reported failure ($server_result)"
+fi
+echo success!
+status=0
 exit
-- 
2.20.1

^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH V2 09/16] src/locktest: Clean up error output
  2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
                   ` (7 preceding siblings ...)
  2019-09-23 17:51 ` [PATCH V2 08/16] generic/131: Save stderr for debugging ira.weiny
@ 2019-09-23 17:51 ` ira.weiny
  2019-09-23 17:51 ` [PATCH V2 10/16] src/locktest: Audit all debug output ira.weiny
                   ` (2 subsequent siblings)
  11 siblings, 0 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:51 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

Add some debugging
Make sure all errors go to stderr
Clean up formatting and make failures stand out
Report test results for the client not just the server

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Ira Weiny <ira.weiny@intel.com>

---
Changes from v1:
	Moved earlier in the series

 src/locktest.c | 45 ++++++++++++++++++++++-----------------------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/src/locktest.c b/src/locktest.c
index 241e7c451724..159d13291f79 100644
--- a/src/locktest.c
+++ b/src/locktest.c
@@ -827,6 +827,8 @@ main(int argc, char *argv[])
     }
 
     filename=argv[optind];
+    if (debug)
+	fprintf(stderr, "Working on file : %s\n", filename);
     if (do_open(O_RDWR) == FAIL)
 	exit(1);
 
@@ -905,10 +907,10 @@ main(int argc, char *argv[])
         struct hostent  *servInfo;
 
         if ((servInfo = gethostbyname(host)) == NULL) {
-	    printf("Couldn't get hostbyname for %s", host);
+	    fprintf(stderr, "Couldn't get hostbyname for %s", host);
 	    if (h_errno == HOST_NOT_FOUND)
-		printf(": host not found");
-	    printf("\n");
+		fprintf(stderr, ": host not found");
+	    fprintf(stderr, "\n");
             exit(1);
             /*NOTREACHED*/
         }
@@ -1011,16 +1013,14 @@ main(int argc, char *argv[])
 		    if( result != tests[index][RESULT]) {
 			fail_flag++;
 			/* We have a failure */
-			if(debug)
-			    fprintf(stderr, "Server failure in test %d, while %sing using offset %lld, length %lld - err = %d:%s\n", 
-					ctl.test,
-					get_cmd_str(tests[index][COMMAND]),
-						(long long)tests[index][OFFSET],
-						(long long)tests[index][LENGTH],
-						saved_errno, strerror(saved_errno));
-			fprintf(stderr, "Server failure in %lld:%s\n",
-					(long long)tests[index][TEST_NUM],
-					descriptions[tests[index][TEST_NUM] - 1]);
+			fprintf(stderr, "     ***** Server failure *****\n");
+			fprintf(stderr, "     in test %d, while %sing using offset %lld, length %lld - err = %d:%s\n", 
+				ctl.test, get_cmd_str(tests[index][COMMAND]),
+				(long long)tests[index][OFFSET],
+				(long long)tests[index][LENGTH],
+				saved_errno, strerror(saved_errno));
+			fprintf(stderr, "     %d:%s\n",
+					ctl.test, descriptions[ctl.test - 1]);
 		    }
 		}
 	    /* else send it off to the client */
@@ -1047,14 +1047,13 @@ main(int argc, char *argv[])
 		     * not what the command returned */
 		    if( ctl.result == FAIL ) {
 			fail_flag++;
-			if(debug)
-			    fprintf(stderr, "Client failure in test %d, while %sing using offset %lld, length %lld - err = %d:%s\n",
+			fprintf(stderr, "     ***** Client failure *****\n");
+			fprintf(stderr, "     in test %d, while %sing using offset %lld, length %lld - err = %d:%s\n",
 					ctl.test, get_cmd_str(ctl.command),
 					(long long)ctl.offset, (long long)ctl.length,
 					ctl.error, strerror(ctl.error));
-			fprintf(stderr, "Client failure in %lld:%s\n",
-					(long long)tests[index][TEST_NUM],
-					descriptions[tests[index][TEST_NUM] - 1]);
+			fprintf(stderr, "     %d:%s\n",
+					ctl.test, descriptions[ctl.test - 1]);
 		    }
 		}
 	    }
@@ -1110,9 +1109,10 @@ main(int argc, char *argv[])
 		    break;
 	    }
 	    if( result != ctl.result ) {
-		if(debug)
-		    fprintf(stderr,"Got %d, wanted %d\n",
-				result, ctl.result);
+		fprintf(stderr,"Failure in %d:%s\n",
+			ctl.test, descriptions[ctl.test - 1]);
+		fprintf(stderr,"     Got %d, wanted %d\n",
+			result, ctl.result);
 		ctl.result = FAIL;
 		ctl.error = saved_errno;
 		fail_count++;
@@ -1130,8 +1130,7 @@ main(int argc, char *argv[])
 	    }
 	}
     }
-    if(server)
-	printf("%d tests run, %d failed\n", test_count, fail_count);
+    fprintf(stderr, "%d tests run, %d failed\n", test_count, fail_count);
 }   
     
     exit(fail_count);
-- 
2.20.1

^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH V2 10/16] src/locktest: Audit all debug output
  2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
                   ` (8 preceding siblings ...)
  2019-09-23 17:51 ` [PATCH V2 09/16] src/locktest: Clean up error output ira.weiny
@ 2019-09-23 17:51 ` ira.weiny
  2019-09-23 17:51 ` [PATCH V2 11/16] src/locktest: Add run() function ira.weiny
  2019-09-23 17:58 ` [PATCH V2 00/16] Fix locktest and add lease testing to it Ira Weiny
  11 siblings, 0 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:51 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

Audit all the debug output to be clear on what failed so that we can
remove the debug flag from the script.

Specifically, remove the need for a debug flag on system call error
output.  This helps to indicate what happened when an individual test
step fails.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Ira Weiny <ira.weiny@intel.com>

---
Changes from V1:
	Moved earlier in the series

 src/locktest.c    | 19 +++++++++++--------
 tests/generic/131 |  5 ++---
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/src/locktest.c b/src/locktest.c
index 159d13291f79..3dc74947f100 100644
--- a/src/locktest.c
+++ b/src/locktest.c
@@ -647,7 +647,7 @@ static int do_lock(int cmd, int type, int start, int length)
     ret = fcntl(filedes, cmd, &fl);
     saved_errno = errno;	    
 
-    if(debug > 1 && ret)
+    if(ret)
 	fprintf(stderr, "do_lock: ret = %d, errno = %d (%s)\n", ret, errno, strerror(errno));
 
     return(ret==0?PASS:FAIL);
@@ -665,8 +665,11 @@ int do_close(void)
 
     saved_errno = errno;	    
 	
-    if (errno)
+    if (errno) {
+	fprintf(stderr, "%s errno = %d (%s)\n",
+		__FILE__, errno, strerror(errno));
 	return FAIL;
+    }
     return PASS;
 }
 
@@ -686,7 +689,7 @@ send_ctl(void)
 {
     int         nwrite;
 
-    if (debug > 1) {
+    if (debug) {
 	fprintf(stderr, "send_ctl: test=%d, command=%d offset=%"LL"d, length=%"LL"d, result=%d, error=%d\n", 
                 ctl.test, ctl.command, (long long)ctl.offset, (long long)ctl.length,ctl.result, ctl.error);
     }
@@ -741,7 +744,7 @@ void recv_ctl(void)
     ctl.index= bswap_uint32(ctl.index);
     ctl.error= bswap_uint32(ctl.error);
 
-    if (debug > 1) {
+    if (debug) {
 	fprintf(stderr, "recv_ctl: test=%d, command=%d offset=%"LL"d, length=%"LL"d, result=%d, error=%d\n", 
                 ctl.test, ctl.command, (long long)ctl.offset, (long long)ctl.length, ctl.result, ctl.error);
     }
@@ -977,7 +980,7 @@ main(int argc, char *argv[])
 	    }
 	    /* If we have a server command, deal with it */
 	    if(tests[index][WHO] == SERVER) {
-		if(debug>1)
+		if(debug)
 		    fprintf(stderr, "Got a server command (%d)\n", index);
 		if(tests[index][TEST_NUM] == 0) {
 		    index++;
@@ -1031,7 +1034,7 @@ main(int argc, char *argv[])
 		} 
 		/* get the client to do something */
 		init_ctl(index);
-		if(debug > 1)
+		if(debug)
 		    fprintf(stderr, "Sending command to client (%d) - %s - %lld:%lld\n", 
 					index,
 					get_cmd_str(ctl.command),
@@ -1068,7 +1071,7 @@ main(int argc, char *argv[])
 		
 	    index++;
 	} else { /* CLIENT */
-	    if(debug > 2)
+	    if(debug)
 		fprintf(stderr,"client: waiting...\n");
 	    /* wait for the server to do something */
 	    recv_ctl();
@@ -1120,7 +1123,7 @@ main(int argc, char *argv[])
 		ctl.result = PASS;
 		ctl.error = 0;
 	    }
-	    if(debug > 2)
+	    if(debug)
 		fprintf(stderr,"client: sending result to server (%d)\n", ctl.index);
 	    /* Send result to the server */
 	    send_ctl();
diff --git a/tests/generic/131 b/tests/generic/131
index 4d90411d4a19..9990f38b26a3 100755
--- a/tests/generic/131
+++ b/tests/generic/131
@@ -14,7 +14,6 @@ here=`pwd`
 tmp=/tmp/$$
 status=1	# failure is the default!
 trap "_cleanup; exit \$status" 0 1 2 3 15
-debug="-d"
 
 TESTFILE=$TEST_DIR/lock_file
 
@@ -63,7 +62,7 @@ function dump_logs_fail()
 }
 
 # Start the server
-src/locktest $debug $TESTFILE 2> $SERVER_LOG 1> $SERVER_PORT &
+src/locktest $TESTFILE 2> $SERVER_LOG 1> $SERVER_PORT &
 server_pid=$!
 
 timeout=30
@@ -89,7 +88,7 @@ fi
 
 # Start the client
 
-src/locktest $debug -p $PORT -h localhost $TESTFILE 2> $CLIENT_LOG
+src/locktest -p $PORT -h localhost $TESTFILE 2> $CLIENT_LOG
 client_result=$?
 client_pid=$!
 if [ $client_result -ne 0 ]; then
-- 
2.20.1

^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH V2 11/16] src/locktest: Add run() function
  2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
                   ` (9 preceding siblings ...)
  2019-09-23 17:51 ` [PATCH V2 10/16] src/locktest: Audit all debug output ira.weiny
@ 2019-09-23 17:51 ` ira.weiny
  2019-09-23 17:58 ` [PATCH V2 00/16] Fix locktest and add lease testing to it Ira Weiny
  11 siblings, 0 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:51 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

Separate the functionality of main() into socket set up and run().  Pass
the test information to run() rather than have it be gloabal.  This is
in preparation for adding a separate lease test array.

Signed-off-by: Ira Weiny <ira.weiny@intel.com>

---
Changes from V1:
	New patch for this series

 src/locktest.c | 30 ++++++++++++++++++------------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/locktest.c b/src/locktest.c
index 3dc74947f100..076781badaa1 100644
--- a/src/locktest.c
+++ b/src/locktest.c
@@ -146,7 +146,7 @@ static char *get_cmd_str(int cmd)
  * (or vice versa)
  */
 
-char *descriptions[] = {
+char *lock_descriptions[] = {
     /* 1 */"Add a lock to an empty lock list",
     /* 2 */"Add a lock to the start and end of a list - no overlaps",
     /* 3 */"Add a lock to the middle of a list - no overlap",
@@ -183,7 +183,7 @@ char *descriptions[] = {
     #endif
 };
 
-static int64_t tests[][6] =
+static int64_t lock_tests[][6] =
 	/*	test #	Action	[offset|flags]	length		expected	server/client */
 	{ 	
 	/* Various simple tests exercising the list */
@@ -673,7 +673,7 @@ int do_close(void)
     return PASS;
 }
 
-static void init_ctl(int32_t index)
+static void init_ctl(int64_t tests[][6], int32_t index)
 {
     ctl.test= (int32_t)tests[index][TEST_NUM];
     ctl.command = (int32_t)tests[index][COMMAND];
@@ -765,6 +765,9 @@ cleanup(void)
     PLATFORM_CLEANUP();
 }
 
+int
+run(int64_t tests[][6], char *descriptions[]);
+
 int
 main(int argc, char *argv[])
 {
@@ -778,7 +781,7 @@ main(int argc, char *argv[])
     char	*p;
     extern char	*optarg;
     extern int	optind;
-    int fail_count = 0;; 
+    int fail_count = 0;
     
     atexit(cleanup);
     
@@ -962,7 +965,13 @@ main(int argc, char *argv[])
      *
      * real work is in here ...
      */
-    i = 0;
+    fail_count = run(lock_tests, lock_descriptions);
+
+    exit(fail_count);
+    /*NOTREACHED*/
+}
+
+int run(int64_t tests[][6], char *descriptions[])
 {
     int index = 0;
     int end = 0;
@@ -970,6 +979,7 @@ main(int argc, char *argv[])
     int last_test = 0;
     int test_count = -1;
     int fail_flag = 0;
+    int fail_count = 0;
     while(!end) {
 	if (server) {
 	    if(testnumber > 0) {
@@ -1033,7 +1043,7 @@ main(int argc, char *argv[])
 		    end=1;
 		} 
 		/* get the client to do something */
-		init_ctl(index);
+		init_ctl(tests, index);
 		if(debug)
 		    fprintf(stderr, "Sending command to client (%d) - %s - %lld:%lld\n", 
 					index,
@@ -1134,10 +1144,6 @@ main(int argc, char *argv[])
 	}
     }
     fprintf(stderr, "%d tests run, %d failed\n", test_count, fail_count);
-}   
-    
-    exit(fail_count);
-    /*NOTREACHED*/
-}
-
 
+    return fail_count;
+}
-- 
2.20.1

^ permalink raw reply related	[flat|nested] 14+ messages in thread

* Re: [PATCH V2 00/16] Fix locktest and add lease testing to it
  2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
                   ` (10 preceding siblings ...)
  2019-09-23 17:51 ` [PATCH V2 11/16] src/locktest: Add run() function ira.weiny
@ 2019-09-23 17:58 ` Ira Weiny
  11 siblings, 0 replies; 14+ messages in thread
From: Ira Weiny @ 2019-09-23 17:58 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton

My apologies...  git-send-email seems to be hanging after sending most of
these patches...  :-/

Not sure why.  But it has done it again.  I'm probably going to send the last 2
over.  This series can be ignored....

Very sorry,
Ira

On Mon, Sep 23, 2019 at 10:51:48AM -0700, 'Ira Weiny' wrote:
> From: Ira Weiny <ira.weiny@intel.com>
> 
> Add lease tests[1] to locktest because they share so much code.  Make running
> of lease tests separate as an '-L' option.
> 
> To make things cleaner update the lock test code and test script.  This
> includes fixing a rather serious bug.                                                                                                                 
> 
> Finally update the error output to help identify any steps which fail during
> testing.                                                                                                                                              
> 
> Changes from V1:
> 	Create a new option '-L' to run lease testing
> 	Created 568 test script which shared common code with 131
> 	Moved 2 patches earlier in the series
> 		[PATCH V2 09/16] src/locktest: Clean up error output
> 		[PATCH V2 10/16] src/locktest: Audit all debug output
> 	Added 3 patches
> 		[PATCH V2 11/16] src/locktest: Add run() function
> 		[PATCH V2 15/16] common/locktest: Add common locktest functions
> 		[PATCH V2 16/16] generic/568: Add lease testing
> 
> Ira Weiny (16):
>   src/locktest: Remove unnecessary sleep
>   src/locktest: Remove OPEN macro
>   src/locktest: Change command macro names
>   src/locktest: Add get_cmd_str
>   src/locktest.c: Clean up client command passing
>   src/locktest.c: Fix return code if last test fails
>   generic/131: Clean up pid variables
>   generic/131: Save stderr for debugging
>   src/locktest: Clean up error output
>   src/locktest: Audit all debug output
>   src/locktest: Add run() function
>   src/locktest: Add simple lease testing
>   src/locktest: Add lease testing for basic signal reception
>   src/locktest: Add truncate lease tests
>   common/locktest: Add common locktest functions
>   generic/568: Add lease testing
> 
>  common/locktest       |  95 ++++
>  src/locktest.c        | 999 +++++++++++++++++++++++++++---------------
>  tests/generic/131     |  54 +--
>  tests/generic/568     |  32 ++
>  tests/generic/568.out |   2 +
>  tests/generic/group   |   1 +
>  6 files changed, 786 insertions(+), 397 deletions(-)
>  create mode 100644 common/locktest
>  create mode 100755 tests/generic/568
>  create mode 100644 tests/generic/568.out
> 
> -- 
> 2.20.1
> 

^ permalink raw reply	[flat|nested] 14+ messages in thread

* [PATCH V2 10/16] src/locktest: Audit all debug output
  2019-09-23 17:53 ira.weiny
@ 2019-09-23 17:53 ` ira.weiny
  0 siblings, 0 replies; 14+ messages in thread
From: ira.weiny @ 2019-09-23 17:53 UTC (permalink / raw)
  To: fstests, Eryu Guan
  Cc: john.hubbard, Dave Chinner, Jan Kara, Jason Gunthorpe,
	dan.j.williams, Jeff Layton, Ira Weiny

From: Ira Weiny <ira.weiny@intel.com>

Audit all the debug output to be clear on what failed so that we can
remove the debug flag from the script.

Specifically, remove the need for a debug flag on system call error
output.  This helps to indicate what happened when an individual test
step fails.

Reviewed-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Ira Weiny <ira.weiny@intel.com>

---
Changes from V1:
	Moved earlier in the series

 src/locktest.c    | 19 +++++++++++--------
 tests/generic/131 |  5 ++---
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/src/locktest.c b/src/locktest.c
index 159d13291f79..3dc74947f100 100644
--- a/src/locktest.c
+++ b/src/locktest.c
@@ -647,7 +647,7 @@ static int do_lock(int cmd, int type, int start, int length)
     ret = fcntl(filedes, cmd, &fl);
     saved_errno = errno;	    
 
-    if(debug > 1 && ret)
+    if(ret)
 	fprintf(stderr, "do_lock: ret = %d, errno = %d (%s)\n", ret, errno, strerror(errno));
 
     return(ret==0?PASS:FAIL);
@@ -665,8 +665,11 @@ int do_close(void)
 
     saved_errno = errno;	    
 	
-    if (errno)
+    if (errno) {
+	fprintf(stderr, "%s errno = %d (%s)\n",
+		__FILE__, errno, strerror(errno));
 	return FAIL;
+    }
     return PASS;
 }
 
@@ -686,7 +689,7 @@ send_ctl(void)
 {
     int         nwrite;
 
-    if (debug > 1) {
+    if (debug) {
 	fprintf(stderr, "send_ctl: test=%d, command=%d offset=%"LL"d, length=%"LL"d, result=%d, error=%d\n", 
                 ctl.test, ctl.command, (long long)ctl.offset, (long long)ctl.length,ctl.result, ctl.error);
     }
@@ -741,7 +744,7 @@ void recv_ctl(void)
     ctl.index= bswap_uint32(ctl.index);
     ctl.error= bswap_uint32(ctl.error);
 
-    if (debug > 1) {
+    if (debug) {
 	fprintf(stderr, "recv_ctl: test=%d, command=%d offset=%"LL"d, length=%"LL"d, result=%d, error=%d\n", 
                 ctl.test, ctl.command, (long long)ctl.offset, (long long)ctl.length, ctl.result, ctl.error);
     }
@@ -977,7 +980,7 @@ main(int argc, char *argv[])
 	    }
 	    /* If we have a server command, deal with it */
 	    if(tests[index][WHO] == SERVER) {
-		if(debug>1)
+		if(debug)
 		    fprintf(stderr, "Got a server command (%d)\n", index);
 		if(tests[index][TEST_NUM] == 0) {
 		    index++;
@@ -1031,7 +1034,7 @@ main(int argc, char *argv[])
 		} 
 		/* get the client to do something */
 		init_ctl(index);
-		if(debug > 1)
+		if(debug)
 		    fprintf(stderr, "Sending command to client (%d) - %s - %lld:%lld\n", 
 					index,
 					get_cmd_str(ctl.command),
@@ -1068,7 +1071,7 @@ main(int argc, char *argv[])
 		
 	    index++;
 	} else { /* CLIENT */
-	    if(debug > 2)
+	    if(debug)
 		fprintf(stderr,"client: waiting...\n");
 	    /* wait for the server to do something */
 	    recv_ctl();
@@ -1120,7 +1123,7 @@ main(int argc, char *argv[])
 		ctl.result = PASS;
 		ctl.error = 0;
 	    }
-	    if(debug > 2)
+	    if(debug)
 		fprintf(stderr,"client: sending result to server (%d)\n", ctl.index);
 	    /* Send result to the server */
 	    send_ctl();
diff --git a/tests/generic/131 b/tests/generic/131
index 4d90411d4a19..9990f38b26a3 100755
--- a/tests/generic/131
+++ b/tests/generic/131
@@ -14,7 +14,6 @@ here=`pwd`
 tmp=/tmp/$$
 status=1	# failure is the default!
 trap "_cleanup; exit \$status" 0 1 2 3 15
-debug="-d"
 
 TESTFILE=$TEST_DIR/lock_file
 
@@ -63,7 +62,7 @@ function dump_logs_fail()
 }
 
 # Start the server
-src/locktest $debug $TESTFILE 2> $SERVER_LOG 1> $SERVER_PORT &
+src/locktest $TESTFILE 2> $SERVER_LOG 1> $SERVER_PORT &
 server_pid=$!
 
 timeout=30
@@ -89,7 +88,7 @@ fi
 
 # Start the client
 
-src/locktest $debug -p $PORT -h localhost $TESTFILE 2> $CLIENT_LOG
+src/locktest -p $PORT -h localhost $TESTFILE 2> $CLIENT_LOG
 client_result=$?
 client_pid=$!
 if [ $client_result -ne 0 ]; then
-- 
2.20.1

^ permalink raw reply related	[flat|nested] 14+ messages in thread

end of thread, other threads:[~2019-09-23 17:58 UTC | newest]

Thread overview: 14+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-09-23 17:51 [PATCH V2 00/16] Fix locktest and add lease testing to it ira.weiny
2019-09-23 17:51 ` [PATCH V2 01/16] src/locktest: Remove unnecessary sleep ira.weiny
2019-09-23 17:51 ` [PATCH V2 02/16] src/locktest: Remove OPEN macro ira.weiny
2019-09-23 17:51 ` [PATCH V2 03/16] src/locktest: Change command macro names ira.weiny
2019-09-23 17:51 ` [PATCH V2 04/16] src/locktest: Add get_cmd_str ira.weiny
2019-09-23 17:51 ` [PATCH V2 05/16] src/locktest.c: Clean up client command passing ira.weiny
2019-09-23 17:51 ` [PATCH V2 06/16] src/locktest.c: Fix return code if last test fails ira.weiny
2019-09-23 17:51 ` [PATCH V2 07/16] generic/131: Clean up pid variables ira.weiny
2019-09-23 17:51 ` [PATCH V2 08/16] generic/131: Save stderr for debugging ira.weiny
2019-09-23 17:51 ` [PATCH V2 09/16] src/locktest: Clean up error output ira.weiny
2019-09-23 17:51 ` [PATCH V2 10/16] src/locktest: Audit all debug output ira.weiny
2019-09-23 17:51 ` [PATCH V2 11/16] src/locktest: Add run() function ira.weiny
2019-09-23 17:58 ` [PATCH V2 00/16] Fix locktest and add lease testing to it Ira Weiny
2019-09-23 17:53 ira.weiny
2019-09-23 17:53 ` [PATCH V2 10/16] src/locktest: Audit all debug output ira.weiny

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).