evin/ms-nfs41-client
3
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

cthon: added patches for connectathon

Browse source 
patches apply on top of http://www.connectathon.org/nfstests.zip

Signed-off-by: Casey Bodley <cbodley@citi.umich.edu>
This commit is contained in:
Casey Bodley 2010-10-11 15:37:56 -04:00
parent 0ad4db4fad
commit 55ff9d855d
11 changed files with 1182 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

577
tests/0007-cthon-porting-lock-tests-to-win32-api.patch Normal file
View file

@ -0,0 +1,577 @@
From 8a73c727370c3062ff06f9203efbcc81ad37497e Mon Sep 17 00:00:00 2001
From: Casey Bodley <cbodley@citi.umich.edu>
Date: Mon, 11 Oct 2010 15:25:16 -0400
Subject: [PATCH 07/11] cthon: porting lock tests to win32 api
added '#ifdef _WIN32' blocks to implement the following changes:
int testfd -> HANDLE testfd
open() -> CreateFile()
close() -> CloseHandle()
unlink() -> DeleteFile()
write() -> WriteFile()
read() -> ReadFile()
ftruncate() -> SetFilePointer()+SetEndOfFile()
mmap() -> CreateFileMapping()+MapViewOfFile()
munmap() -> UnmapViewOfFile()+CloseHandle()
lockf(F_LOCK) -> LockFileEx()
lockf(F_TLOCK) -> LockFile()
lockf(F_ULOCK) -> UnlockFileEx()
lockf(F_TEST) -> LockFile()+UnlockFileEx()
some tests expect an overflow error when the lock range wraps, but win32 allows this. changed the expected errors for checks in _WIN32
skipping test8, which times 1000 consecutive calls to lock/unlock. this doesn't tell us anything, except that we're slow
skipping test10 which checks for splitting lock regions; in windows, the unlock range must match lock range exactly
for test11, the _WIN32 path reopens the file instead of using dup()/dup2(); the windows DuplicateHandle() function works differently, in that both copies of the handle must be closed before it releases its locks
for test12, it forks an extra 'subchild' process, takes a lock, then kills the process to make sure it releases the lock. had to move the open call from the child block into the subchild block for this to work; otherwise, the lock wouldn't release because the child still holds a handle
---
lock/tlock.c | 273 +++++++++++++++++++++++++++++++++++++++++++++++++++++-----
1 files changed, 251 insertions(+), 22 deletions(-)
diff --git a/lock/tlock.c b/lock/tlock.c
index fe8c760..dac3519 100644
--- a/lock/tlock.c
+++ b/lock/tlock.c
@@ -54,6 +54,12 @@
#endif
#endif
+#define _WIN32
+
+#ifdef _WIN32
+# include <Windows.h>
+#endif
+
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
@@ -135,8 +141,16 @@ static int pidpipe[2];
static char testfile[256]; /* file for locking test */
static char *filepath = ".";
+#ifdef _WIN32
+static HANDLE testfd;
+#else
static int testfd;
+#endif
+
#ifdef MMAP
+#ifdef _WIN32
+static HANDLE mappinghandle;
+#endif
static caddr_t mappedaddr; /* address file is mapped to (some tests) */
static off_t mappedlen;
#endif
@@ -586,12 +600,21 @@ open_testfile(flags, modes)
int flags;
int modes;
{
-
+#ifdef _WIN32
+ testfd = CreateFile(testfile, GENERIC_READ | GENERIC_WRITE,
+ FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS,
+ FILE_ATTRIBUTE_NORMAL, NULL);
+ if (testfd == INVALID_HANDLE_VALUE) {
+ fprintf(stderr, "CreateFile(%s) returned %d\n", testfile, GetLastError());
+ testexit(1);
+ }
+#else
testfd = open(testfile, flags, modes);
if (testfd < 0) {
perror("tlock: open");
testexit(1);
}
+#endif
}
static void
@@ -599,11 +622,17 @@ close_testfile(cleanup)
int cleanup;
{
- if (cleanup == JUST_CLOSE)
- comment("Closed testfile.");
+ if (cleanup == JUST_CLOSE)
+ comment("Closed testfile.");
+#ifdef _WIN32
+ CloseHandle(testfd);
+ if (cleanup == DO_UNLINK)
+ DeleteFile(testfile);
+#else
close(testfd);
if (cleanup == DO_UNLINK)
(void) unlink(testfile);
+#endif
}
static void
@@ -615,12 +644,28 @@ write_testfile(datap, offset, count, do_comment)
{
int result;
+#ifdef _WIN32
+ {
+ DWORD bytes = 0;
+ LARGE_INTEGER off = { offset };
+ OVERLAPPED overlapped = { 0 };
+ overlapped.Offset = off.LowPart;
+ overlapped.OffsetHigh = off.HighPart;
+
+ if (!WriteFile(testfd, datap, count, &bytes, &overlapped)) {
+ fprintf(stderr, "WriteFile() failed with %d\n", GetLastError());
+ testexit(1);
+ }
+ result = bytes;
+ }
+#else
(void) lseek(testfd, offset, 0);
result = write(testfd, datap, count);
if (result < 0) {
perror("tlock: testfile write");
testexit(1);
}
+#endif
if (result != count) {
fprintf(stderr, "tlock: short write (got %d, expected %d)\n",
result, count);
@@ -663,6 +708,21 @@ read_testfile(test, sec, datap, offset, count, pass, fail)
exit(1);
}
+#ifdef _WIN32
+ {
+ DWORD bytes = 0;
+ LARGE_INTEGER off = { offset };
+ OVERLAPPED overlapped = { 0 };
+ overlapped.Offset = off.LowPart;
+ overlapped.OffsetHigh = off.HighPart;
+
+ if (!ReadFile(testfd, array, count, &bytes, &overlapped)) {
+ fprintf(stderr, "ReadFile() failed with %d\n", GetLastError());
+ testexit(1);
+ }
+ result = bytes;
+ }
+#else
(void) lseek(testfd, offset, 0);
if (count > IORATE_BUFSIZE)
count = IORATE_BUFSIZE;
@@ -671,6 +731,7 @@ read_testfile(test, sec, datap, offset, count, pass, fail)
perror("tlock: testfile read");
testexit(1);
}
+#endif
if (result != count) {
fprintf(stderr, "tlock: short read (got %d, expected %d)\n",
result, count);
@@ -703,7 +764,6 @@ testdup2(fd1, fd2)
int fd1;
int fd2;
{
-
if (dup2(fd1, fd2) < 0) {
perror("tlock: dup2");
testexit(1);
@@ -713,12 +773,22 @@ testdup2(fd1, fd2)
static void
testtruncate()
{
-
- comment("Truncated testfile.");
+ comment("Truncated testfile.");
+#ifdef _WIN32
+ if (SetFilePointer(testfd, 0, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
+ fprintf(stderr, "SetFilePointer() failed with %d\n", GetLastError());
+ testexit(1);
+ }
+ if (!SetEndOfFile(testfd)) {
+ fprintf(stderr, "SetEndOfFile() failed with %d\n", GetLastError());
+ testexit(1);
+ }
+#else
if (ftruncate(testfd, (off_t)0) < 0) {
perror("tlock: ftruncate");
testexit(1);
}
+#endif
}
#ifdef MMAP
@@ -735,25 +805,120 @@ testtruncate()
static int
testmmap()
{
+#ifdef _WIN32
+ LARGE_INTEGER len = { mappedlen };
+
+ mappinghandle = CreateFileMapping(testfd, NULL,
+ PAGE_READWRITE, len.HighPart, len.LowPart, NULL);
+ if (mappinghandle == INVALID_HANDLE_VALUE)
+ return GetLastError();
+
+ mappedaddr = MapViewOfFile(mappinghandle, FILE_MAP_READ | FILE_MAP_WRITE,
+ 0, 0, len.QuadPart);
+ if (mappedaddr == NULL)
+ return GetLastError();
+#else
mappedaddr = mmap(0, mappedlen, PROT_READ | PROT_WRITE, MAP_SHARED,
testfd, (off_t)0);
if (mappedaddr == (caddr_t)MAP_FAILED)
return (errno);
+#endif
return (0);
}
static void
testmunmap()
{
- comment("unmap testfile.");
+ comment("unmap testfile.");
+#ifdef _WIN32
+ if (!UnmapViewOfFile(mappedaddr)) {
+ fprintf(stderr, "UnmapViewOfFile() failed with %d\n", GetLastError());
+ testexit(1);
+ }
+ CloseHandle(mappinghandle);
+#else
if (munmap(mappedaddr, mappedlen) < 0) {
perror("Can't unmap testfile.");
testexit(1);
}
+#endif
mappedaddr = (caddr_t)0xdeadbeef;
}
#endif /* MMAP */
+#ifdef _WIN32
+
+static int map_lock_error(int num, int sec, int status) {
+ switch (status) {
+ case NO_ERROR: return 0;
+ case ERROR_NOT_LOCKED:
+ case ERROR_LOCK_VIOLATION: return denied_err;
+ default:
+ comment("%d.%d unexpected windows error %d", num, sec, status);
+ testexit(1);
+ }
+}
+
+static void
+test(num, sec, func, offset, length, pass, fail)
+int num; /* test number */
+int sec; /* section number */
+int func; /* lockf function to invoke */
+off_t offset; /* starting offset of lock */
+off_t length; /* length of lock */
+int pass; /* expected return code */
+int fail; /* error vs warning */
+{
+ int result = PASS;
+ LARGE_INTEGER off = { offset };
+ LARGE_INTEGER len = { length };
+ OVERLAPPED overlapped = { 0 };
+ overlapped.Offset = off.LowPart;
+ overlapped.OffsetHigh = off.HighPart;
+
+ if (off.QuadPart + len.QuadPart < 0) {
+ result = EINVAL;
+ goto out;
+ }
+ if (length == 0)
+ len.QuadPart = ULLONG_MAX - offset;
+ if (len.QuadPart == 0) {
+ result = EINVAL;
+ goto out;
+ }
+
+ switch (func) {
+ case F_LOCK: /* blocking lock */
+ if (!LockFileEx(testfd, LOCKFILE_EXCLUSIVE_LOCK,
+ 0, len.LowPart, len.HighPart, &overlapped))
+ result = map_lock_error(num, sec, GetLastError());
+ break;
+
+ case F_TLOCK: /* non-blocking lock */
+ if (!LockFile(testfd, off.LowPart, off.HighPart, len.LowPart, len.HighPart))
+ result = map_lock_error(num, sec, GetLastError());
+ break;
+
+ case F_ULOCK:
+ if (!UnlockFileEx(testfd, 0, len.LowPart, len.HighPart, &overlapped))
+ result = map_lock_error(num, sec, GetLastError());
+ break;
+
+ case F_TEST:
+ if (!LockFile(testfd, off.LowPart, off.HighPart, len.LowPart, len.HighPart)) {
+ result = map_lock_error(num, sec, GetLastError());
+ } else if (!UnlockFileEx(testfd, 0, len.LowPart, len.HighPart, &overlapped)) {
+ fprintf(stderr, "UnlockFileEx() returned %d\n", GetLastError());
+ testexit(1);
+ }
+ break;
+ }
+out:
+ report(num, sec, tfunstr(func), offset, length, pass, result, fail);
+}
+
+#else /* !_WIN32 */
+
#ifdef USE_LOCKF
static void
@@ -854,11 +1019,16 @@ test(num, sec, func, offset, length, pass, fail)
}
#endif /* USE_LOCKF */
+#endif /* !_WIN32 */
static void
rate(cnt)
int cnt;
{
+#ifdef _WIN32
+ LARGE_INTEGER len = { 1 };
+ OVERLAPPED overlapped = { 0 };
+#endif
int i;
long beg;
long end;
@@ -867,9 +1037,17 @@ rate(cnt)
beg = times(&tms);
for (i = 0; i < cnt; i++) {
+#ifdef _WIN32
+ if (!LockFileEx(testfd, LOCKFILE_EXCLUSIVE_LOCK, 0,
+ len.LowPart, len.HighPart, &overlapped) ||
+ !UnlockFileEx(testfd, 0, len.LowPart,
+ len.HighPart, &overlapped)) {
+ fprintf(stderr, "tlock: rate error=%d.\n", GetLastError());
+#else
if ((lockf(testfd, F_LOCK, 1) != 0) ||
(lockf(testfd, F_ULOCK, 1) != 0)) {
fprintf(stderr, "tlock: rate error=%d.\n", errno);
+#endif
tstfail++;
break;
}
@@ -972,8 +1150,11 @@ test1()
* integer, no overflow). So treat those failures as
* warnings, not fatal.
*/
- test(1, 9, F_TEST, maxeof, maxeof, oflow_err,
- WARN);
+#ifdef _WIN32
+ test(1, 9, F_TEST, maxeof, maxeof, PASS, FATAL);
+#else
+ test(1, 9, F_TEST, maxeof, maxeof, oflow_err, WARN);
+#endif
close_testfile(DO_UNLINK);
childfree(0);
} else {
@@ -1006,10 +1187,12 @@ test2()
test(2, 5, F_TEST, (off_t)1, (off_t)END, denied_err, FATAL);
test(2, 6, F_TEST, (off_t)1, maxeof, denied_err, FATAL);
test(2, 7, F_TEST, maxeof, (off_t)1, denied_err, FATAL);
- test(2, 8, F_TEST, maxeof, (off_t)END, denied_err,
- FATAL);
- test(2, 9, F_TEST, maxeof, maxeof, oflow_err,
- WARN);
+ test(2, 8, F_TEST, maxeof, (off_t)END, denied_err, FATAL);
+#ifdef _WIN32
+ test(2, 9, F_TEST, maxeof, maxeof, denied_err, FATAL);
+#else
+ test(2, 9, F_TEST, maxeof, maxeof, oflow_err, WARN);
+#endif
close_testfile(DO_UNLINK);
parentfree(0);
}
@@ -1135,8 +1318,12 @@ test6()
FATAL);
test(6, 3, F_TEST, maxeof - 1, (off_t)END,
denied_err, FATAL);
- test(6, 4, F_TEST, maxeof, (off_t)1, denied_err, FATAL);
+ test(6, 4, F_TEST, maxeof, (off_t)1, denied_err, FATAL);
+#ifdef _WIN32
+ test(6, 5, F_TEST, maxeof, (off_t)2, denied_err, FATAL);
+#else
test(6, 5, F_TEST, maxeof, (off_t)2, oflow_err, WARN);
+#endif
test(6, 6, F_TEST, maxeof, (off_t)END, denied_err,
FATAL);
test(6, 7, F_TEST, (off_t)maxplus1, (off_t)END, EINVAL,
@@ -1320,7 +1507,9 @@ test10()
static void
test11()
{
+#ifndef _WIN32
int dupfd;
+#endif
char *data = "123456789abcdef";
int datalen;
@@ -1330,28 +1519,42 @@ test11()
parentwait();
header(11, "Make sure close() releases the process's locks.");
open_testfile(OPENFLAGS, OPENMODES);
+#ifndef _WIN32
dupfd = dup(testfd);
+#endif
test(11, 0, F_TLOCK, (off_t)0, (off_t)0, PASS, FATAL);
close_testfile(JUST_CLOSE);
childfree(0);
- parentwait();
- testdup2(dupfd, testfd);
+ parentwait();
+#ifdef _WIN32
+ open_testfile(OPENFLAGS, OPENMODES);
+#else
+ testdup2(dupfd, testfd);
+#endif
test(11, 3, F_TLOCK, (off_t)29, (off_t)1463, PASS, FATAL);
test(11, 4, F_TLOCK, (off_t)0x2000, (off_t)87, PASS, FATAL);
close_testfile(JUST_CLOSE);
childfree(0);
- parentwait();
- testdup2(dupfd, testfd);
+ parentwait();
+#ifdef _WIN32
+ open_testfile(OPENFLAGS, OPENMODES);
+#else
+ testdup2(dupfd, testfd);
+#endif
write_testfile(data, (off_t)0, datalen, COMMENT);
test(11, 7, F_TLOCK, (off_t)0, (off_t)0, PASS, FATAL);
write_testfile(data, (off_t)(datalen - 3), datalen, COMMENT);
close_testfile(JUST_CLOSE);
childfree(0);
- parentwait();
+ parentwait();
+#ifdef _WIN32
+ open_testfile(OPENFLAGS, OPENMODES);
+#else
testdup2(dupfd, testfd);
+#endif
write_testfile(data, (off_t)0, datalen, COMMENT);
test(11, 10, F_TLOCK, (off_t)0, (off_t)0, PASS, FATAL);
testtruncate();
@@ -1359,7 +1562,9 @@ test11()
childfree(0);
parentwait();
+#ifndef _WIN32
close(dupfd);
+#endif
close_testfile(DO_UNLINK);
} else {
parentfree(0);
@@ -1400,8 +1605,10 @@ test12()
open_testfile(OPENFLAGS, OPENMODES);
childfree(0);
- parentwait();
+ parentwait();
+#ifndef _WIN32
(void) lseek(testfd, (off_t)0, 0);
+#endif
if (read(pidpipe[0], &target, sizeof (target)) !=
sizeof (target)) {
perror("can't read pid to kill");
@@ -1420,7 +1627,9 @@ test12()
parentfree(0);
childwait();
+#ifndef _WIN32
open_testfile(OPENFLAGS, OPENMODES);
+#endif
/*
* Create a subprocess to obtain a lock and get killed. If
* the parent kills the regular child, tlock will stop
@@ -1440,7 +1649,9 @@ test12()
if (subchild > 0) {
/* original child */
sleep(wait_time);
+#ifndef _WIN32
(void) lseek(testfd, (off_t)0, 0);
+#endif
if (write(pidpipe[1], &subchild, sizeof (subchild)) !=
sizeof (subchild)) {
perror("can't record pid to kill");
@@ -1449,11 +1660,16 @@ test12()
}
parentfree(0);
childwait();
+#ifndef _WIN32
close_testfile(DO_UNLINK);
+#endif
} else {
/* subchild */
+#ifdef _WIN32
+ open_testfile(OPENFLAGS, OPENMODES);
+#endif
signal(SIGINT, SIG_DFL);
- test(12, 0, F_TLOCK, (off_t)0, (off_t)0, PASS, FATAL);
+ test(12, 0, F_TLOCK, (off_t)0, (off_t)0, PASS, FATAL);
for (;;)
sleep(1);
/* NOTREACHED */
@@ -1489,7 +1705,11 @@ test13()
lock1err = testmmap();
report(13, 1, "mmap", (off_t)0, (off_t)mappedlen, EAGAIN,
lock1err, WARN);
+#ifdef _WIN32
+ test(13, 2, F_ULOCK, (off_t)mappedlen - 2, (off_t)END, PASS, FATAL);
+#else
test(13, 2, F_ULOCK, (off_t)0, (off_t)END, PASS, FATAL);
+#endif
if (lock1err == 0)
testmunmap();
@@ -1505,6 +1725,9 @@ test13()
FATAL);
test(13, 4, F_TLOCK, (off_t)mappedlen - 2, (off_t)END,
lock1err, WARN);
+#ifdef _WIN32
+ testmunmap();
+#endif
close_testfile(DO_UNLINK);
childfree(0);
@@ -1589,21 +1812,27 @@ runtests()
if (DO_TEST(7)) {
test7();
}
+#ifndef _WIN32
if (DO_RATE(8)) {
test8();
}
+#endif
if (DO_MAND(9)) {
test9();
}
+#ifndef _WIN32
+ /* windows doesn't allow splitting lock ranges;
+ * unlock ranges must correspond exactly to lock ranges */
if (DO_TEST(10)) {
test10();
}
+#endif
if (DO_TEST(11)) {
test11();
}
if (DO_TEST(12)) {
test12();
- }
+ }
#ifdef MMAP
if (DO_TEST(13)) {
test13();
--
1.6.4.msysgit.0