From a83bbc9c488fb5b5405a5d1dc13a32d588a2fccd Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Fri, 8 Aug 2014 11:20:45 -0400 Subject: [PATCH] syscall: ignore EINVAL/ENOENT from readdirent on OS X 10.10 On OS X 10.10 Yosemite, if you have a directory that can be returned in a single getdirentries64 call (for example, a directory with one file), and you read from the directory at EOF twice, you get EOF both times: fd = open("dir") getdirentries64(fd) returns data getdirentries64(fd) returns 0 (EOF) getdirentries64(fd) returns 0 (EOF) But if you remove the file in the middle between the two calls, the second call returns an error instead. fd = open("dir") getdirentries64(fd) returns data getdirentries64(fd) returns 0 (EOF) remove("dir/file") getdirentries64(fd) returns ENOENT/EINVAL Whether you get ENOENT or EINVAL depends on exactly what was in the directory. It is deterministic, just data-dependent. This only happens in small directories. A directory containing more data than fits in a 4k getdirentries64 call will return EOF correctly. (It's not clear if the criteria is that the directory be split across multiple getdirentries64 calls or that it be split across multiple file system blocks.) We could change package os to avoid the second read at EOF, and maybe we should, but that's a bit involved. For now, treat the EINVAL/ENOENT as EOF. With this CL, all.bash passes on my MacBook Air running OS X 10.10 (14A299l) and Xcode 6 beta 5 (6A279r). I tried filing an issue with Apple using "Feedback Assistant", but it was unable to send the report and lost it. C program reproducing the issue, also at http://swtch.com/~rsc/readdirbug.c: #include #include #include #include #include #include #include #include static void test(int); int main(void) { int fd, n; DIR *dir; struct dirent *dp; struct stat st; char buf[10000]; long basep; int saw; if(stat("/tmp/readdirbug", &st) >= 0) { fprintf(stderr, "please rm -r /tmp/readdirbug and run again\n"); exit(1); } fprintf(stderr, "mkdir /tmp/readdirbug\n"); if(mkdir("/tmp/readdirbug", 0777) < 0) { perror("mkdir /tmp/readdirbug"); exit(1); } fprintf(stderr, "create /tmp/readdirbug/file1\n"); if((fd = creat("/tmp/readdirbug/file1", 0666)) < 0) { perror("create /tmp/readdirbug/file1"); exit(1); } close(fd); test(0); test(1); fprintf(stderr, "ok - everything worked\n"); } static void test(int doremove) { DIR *dir; struct dirent *dp; int numeof; fprintf(stderr, "\n"); fprintf(stderr, "opendir /tmp/readdirbug\n"); dir = opendir("/tmp/readdirbug"); if(dir == 0) { perror("open /tmp/readdirbug"); exit(1); } numeof = 0; for(;;) { errno = 0; dp = readdir(dir); if(dp != 0) { fprintf(stderr, "readdir: found %s\n", dp->d_name); continue; } if(errno != 0) { perror("readdir"); exit(1); } fprintf(stderr, "readdir: EOF\n"); if(++numeof == 3) break; if(doremove) { fprintf(stderr, "rm /tmp/readdirbug/file1\n"); if(remove("/tmp/readdirbug/file1") < 0) { perror("remove"); exit(1); } } } fprintf(stderr, "closedir\n"); closedir(dir); } Fixes #8423. LGTM=bradfitz, r R=golang-codereviews, bradfitz, dsymonds, dave, r CC=golang-codereviews, iant https://golang.org/cl/119530044 --- src/pkg/syscall/syscall_bsd.go | 35 +++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/src/pkg/syscall/syscall_bsd.go b/src/pkg/syscall/syscall_bsd.go index af563910b1..2556fa8746 100644 --- a/src/pkg/syscall/syscall_bsd.go +++ b/src/pkg/syscall/syscall_bsd.go @@ -68,7 +68,40 @@ func ReadDirent(fd int, buf []byte) (n int, err error) { // actual system call is getdirentries64, 64 is a good guess. // TODO(rsc): Can we use a single global basep for all calls? var base = (*uintptr)(unsafe.Pointer(new(uint64))) - return Getdirentries(fd, buf, base) + n, err = Getdirentries(fd, buf, base) + + // On OS X 10.10 Yosemite, if you have a directory that can be returned + // in a single getdirentries64 call (for example, a directory with one file), + // and you read from the directory at EOF twice, you get EOF both times: + // fd = open("dir") + // getdirentries64(fd) // returns data + // getdirentries64(fd) // returns 0 (EOF) + // getdirentries64(fd) // returns 0 (EOF) + // + // But if you remove the file in the middle between the two calls, the + // second call returns an error instead. + // fd = open("dir") + // getdirentries64(fd) // returns data + // getdirentries64(fd) // returns 0 (EOF) + // remove("dir/file") + // getdirentries64(fd) // returns ENOENT/EINVAL + // + // Whether you get ENOENT or EINVAL depends on exactly what was + // in the directory. It is deterministic, just data-dependent. + // + // This only happens in small directories. A directory containing more data + // than fits in a 4k getdirentries64 call will return EOF correctly. + // (It's not clear if the criteria is that the directory be split across multiple + // getdirentries64 calls or that it be split across multiple file system blocks.) + // + // We could change package os to avoid the second read at EOF, + // and maybe we should, but that's a bit involved. + // For now, treat the EINVAL/ENOENT as EOF. + if runtime.GOOS == "darwin" && (err == EINVAL || err == ENOENT) { + err = nil + } + + return } // Wait status is 7 bits at bottom, either 0 (exited), -- 2.48.1