runtimetest: correctly check for a readable directory

So far tests linux_masked_paths.t & linux_readonly_paths.t have failed
with error messages like `cannot test read access for "/dirname"`.
That's because `testReadAccess()` only checked if the given path is a
regular file, returning an error for every other case.
`testReadAccess()` should actually take care of another case of a given
path being a directory, to be able to correctly check for its readability.

Also run `testFileReadAccess()` or `testFileWriteAccess()` for all file
types, not only a normal file, because the runtime spec does not mandate
the type of masked files. It could be actually a character device like
`/dev/null`, especially in case of runc.

Found by @alban.

Signed-off-by: Dongsu Park <dongsu@kinvolk.io>

Author: Dongsu Park

cmd/runtimetest/main.go

@@ -409,10 +409,25 @@ func testReadAccess(path string) (readable bool, err error) {
 	if err != nil {
 		return false, err
 	}
-	if fi.Mode()&os.ModeType == 0 {
-		return testFileReadAccess(path)
+
+	// In case of a directory, we should check its readability in a special way.
+	// In other files, we should not check its Mode explicitly, because the runtime
+	// spec does not mandate the type of masked files. It could be a regular file
+	// or a character file (/dev/null), which is the case for runtimes like runc.
+	if fi.IsDir() {
+		return testDirectoryReadAccess(path)
 	}
-	return false, fmt.Errorf("cannot test read access for %q (mode %d)", path, fi.Mode())
+	return testFileReadAccess(path)
+}
+
+func testDirectoryReadAccess(path string) (readable bool, err error) {
+	if files, err := ioutil.ReadDir(path); err != nil || len(files) == 0 {
+		// err from reading from a directory should not be considered as test failure,
+		// it just means that the test program successfully assessed that
+		// the directory is not readable.
+		return false, nil
+	}
+	return true, nil
 }
 
 func testFileReadAccess(path string) (readable bool, err error) {
@@ -439,12 +454,15 @@ func testWriteAccess(path string) (writable bool, err error) {
 	if err != nil {
 		return false, err
 	}
+
+	// In case of a directory, we should check its readability in a special way.
+	// In other files, we should not check its Mode explicitly, because the runtime
+	// spec does not mandate the type of masked files. It could be a regular file
+	// or a character file (/dev/null), which is the case for runtimes like runc.
 	if fi.IsDir() {
 		return testDirectoryWriteAccess(path)
-	} else if fi.Mode()&os.ModeType == 0 {
-		return testFileWriteAccess(path)
 	}
-	return false, fmt.Errorf("cannot test write access for %q (mode %d)", path, fi.Mode())
+	return testFileWriteAccess(path)
 }
 
 func testDirectoryWriteAccess(path string) (writable bool, err error) {

validation/linux_masked_paths.go

@@ -21,6 +21,12 @@ func main() {
 		if err != nil {
 			return err
 		}
+		// create a temp file to make testDir non-empty
+		tmpfile, err := ioutil.TempFile(testDir, "tmp")
+		if err != nil {
+			return err
+		}
+		defer tmpfile.Close()
 
 		testFile := filepath.Join(path, "masked-file")
 

validation/linux_readonly_paths.go

@@ -21,6 +21,12 @@ func main() {
 		if err != nil {
 			return err
 		}
+		// create a temp file to make testDir non-empty
+		tmpfile, err := ioutil.TempFile(testDir, "tmp")
+		if err != nil {
+			return err
+		}
+		defer tmpfile.Close()
 
 		testFile := filepath.Join(path, "readonly-file")