Implement some of the missing LFS64 support.

This gives us:

* <dirent.h>
  struct dirent64
  readdir64, readdir64_r, alphasort64, scandir64

* <fcntl.h>
  creat64, openat64, open64.

* <sys/stat.h>
  struct stat64
  fstat64, fstatat64, lstat64, stat64.

* <sys/statvfs.h>
  struct statvfs64
  statvfs64, fstatvfs64.

* <sys/vfs.h>
  struct statfs64
  statfs64, fstatfs64.

This also removes some of the incorrect #define hacks we've had in the
past (for stat64, for example, which we promised to clean up way back
in bug 8472078).

Bug: 11865851
Bug: 8472078
Change-Id: Ia46443521918519f2dfa64d4621027dfd13ac566

5 files changed, 125 insertions, 22 deletions

diff --git a/tests/Android.mk b/tests/Android.mk
index e658b4d52..5ee2596dd 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -59,7 +59,6 @@ libBionicStandardTests_src_files := \
     stack_protector_test.cpp \
     stack_unwinding_test.cpp \
     stack_unwinding_test_impl.c \
-    statvfs_test.cpp \
     stdio_test.cpp \
     stdlib_test.cpp \
     string_test.cpp \
@@ -71,9 +70,11 @@ libBionicStandardTests_src_files := \
     sys_select_test.cpp \
     sys_sendfile_test.cpp \
     sys_stat_test.cpp \
+    sys_statvfs_test.cpp \
     sys_syscall_test.cpp \
     sys_time_test.cpp \
     sys_types_test.cpp \
+    sys_vfs_test.cpp \
     system_properties_test.cpp \
     time_test.cpp \
     unistd_test.cpp \
diff --git a/tests/dirent_test.cpp b/tests/dirent_test.cpp
index 48ca819ef..6aadb3768 100644
--- a/tests/dirent_test.cpp
+++ b/tests/dirent_test.cpp
@@ -37,21 +37,31 @@ static void CheckProcSelf(std::set<std::string>& names) {
   ASSERT_TRUE(names.find("stat") != names.end());
 }
 
-TEST(dirent, scandir) {
+template <typename DirEntT>
+void ScanEntries(DirEntT** entries, int entry_count,
+                 std::set<std::string>& name_set, std::vector<std::string>& name_list) {
+  for (size_t i = 0; i < static_cast<size_t>(entry_count); ++i) {
+    name_set.insert(entries[i]->d_name);
+    name_list.push_back(entries[i]->d_name);
+    free(entries[i]);
+  }
+  free(entries);
+}
+
+TEST(dirent, scandir_scandir64) {
   // Get everything from /proc/self...
   dirent** entries;
   int entry_count = scandir("/proc/self", &entries, NULL, alphasort);
   ASSERT_GE(entry_count, 0);
 
+  dirent64** entries64;
+  int entry_count64 = scandir64("/proc/self", &entries64, NULL, alphasort64);
+  ASSERT_EQ(entry_count, entry_count64);
+
   // Turn the directory entries into a set and vector of the names.
   std::set<std::string> name_set;
   std::vector<std::string> unsorted_name_list;
-  for (size_t i = 0; i < static_cast<size_t>(entry_count); ++i) {
-    name_set.insert(entries[i]->d_name);
-    unsorted_name_list.push_back(entries[i]->d_name);
-    free(entries[i]);
-  }
-  free(entries);
+  ScanEntries(entries, entry_count, name_set, unsorted_name_list);
 
   // No duplicates.
   ASSERT_EQ(name_set.size(), unsorted_name_list.size());
@@ -61,6 +71,13 @@ TEST(dirent, scandir) {
   std::sort(sorted_name_list.begin(), sorted_name_list.end());
   ASSERT_EQ(sorted_name_list, unsorted_name_list);
 
+  // scandir64 returned the same results as scandir.
+  std::set<std::string> name_set64;
+  std::vector<std::string> unsorted_name_list64;
+  ScanEntries(entries64, entry_count64, name_set64, unsorted_name_list64);
+  ASSERT_EQ(name_set, name_set64);
+  ASSERT_EQ(unsorted_name_list, unsorted_name_list64);
+
   CheckProcSelf(name_set);
 }
 
@@ -133,6 +150,23 @@ TEST(dirent, readdir) {
   CheckProcSelf(name_set);
 }
 
+TEST(dirent, readdir64) {
+  DIR* d = opendir("/proc/self");
+  ASSERT_TRUE(d != NULL);
+  std::set<std::string> name_set;
+  errno = 0;
+  dirent64* e;
+  while ((e = readdir64(d)) != NULL) {
+    name_set.insert(e->d_name);
+  }
+  // Reading to the end of the directory is not an error.
+  // readdir64(3) returns NULL, but leaves errno as 0.
+  ASSERT_EQ(0, errno);
+  ASSERT_EQ(closedir(d), 0);
+
+  CheckProcSelf(name_set);
+}
+
 TEST(dirent, readdir_r) {
   DIR* d = opendir("/proc/self");
   ASSERT_TRUE(d != NULL);
@@ -151,6 +185,24 @@ TEST(dirent, readdir_r) {
   CheckProcSelf(name_set);
 }
 
+TEST(dirent, readdir64_r) {
+  DIR* d = opendir("/proc/self");
+  ASSERT_TRUE(d != NULL);
+  std::set<std::string> name_set;
+  errno = 0;
+  dirent64 storage;
+  dirent64* e = NULL;
+  while (readdir64_r(d, &storage, &e) == 0 && e != NULL) {
+    name_set.insert(e->d_name);
+  }
+  // Reading to the end of the directory is not an error.
+  // readdir64_r(3) returns NULL, but leaves errno as 0.
+  ASSERT_EQ(0, errno);
+  ASSERT_EQ(closedir(d), 0);
+
+  CheckProcSelf(name_set);
+}
+
 TEST(dirent, rewinddir) {
   DIR* d = opendir("/proc/self");
   ASSERT_TRUE(d != NULL);
diff --git a/tests/fcntl_test.cpp b/tests/fcntl_test.cpp
index d14243e72..4aac46823 100644
--- a/tests/fcntl_test.cpp
+++ b/tests/fcntl_test.cpp
@@ -35,6 +35,39 @@ TEST(fcntl, fcntl_smoke) {
   flags = fcntl(fd, F_GETFD);
   ASSERT_TRUE(flags != -1);
   ASSERT_EQ(FD_CLOEXEC, flags & FD_CLOEXEC);
+
+  close(fd);
+}
+
+TEST(fcntl, open_open64) {
+  int fd;
+
+  fd = open("/proc/version", O_RDONLY);
+  ASSERT_TRUE(fd != -1);
+  close(fd);
+
+  fd = open64("/proc/version", O_RDONLY);
+  ASSERT_TRUE(fd != -1);
+  close(fd);
+}
+
+TEST(fcntl, openat_openat64) {
+  int fd;
+
+  fd = openat(AT_FDCWD, "/proc/version", O_RDONLY);
+  ASSERT_TRUE(fd != -1);
+  close(fd);
+
+  fd = openat64(AT_FDCWD, "/proc/version", O_RDONLY);
+  ASSERT_TRUE(fd != -1);
+  close(fd);
+}
+
+TEST(fcntl, creat_creat64) {
+  ASSERT_EQ(-1, creat("", 0666));
+  ASSERT_EQ(ENOENT, errno);
+  ASSERT_EQ(-1, creat64("", 0666));
+  ASSERT_EQ(ENOENT, errno);
 }
 
 TEST(fcntl, fallocate_EINVAL) {
diff --git a/tests/sys_stat_test.cpp b/tests/sys_stat_test.cpp
index 176d46243..a57a706e5 100644
--- a/tests/sys_stat_test.cpp
+++ b/tests/sys_stat_test.cpp
@@ -17,6 +17,7 @@
 #include <gtest/gtest.h>
 
 #include <errno.h>
+#include <fcntl.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 
@@ -68,3 +69,12 @@ TEST(sys_stat, mkfifo) {
   ASSERT_TRUE(S_ISFIFO(sb.st_mode));
   unlink(path.c_str());
 }
+
+TEST(sys_stat, stat64_lstat64_fstat64) {
+  struct stat64 sb;
+  ASSERT_EQ(0, stat64("/proc/version", &sb));
+  ASSERT_EQ(0, lstat64("/proc/version", &sb));
+  int fd = open("/proc/version", O_RDONLY);
+  ASSERT_EQ(0, fstat64(fd, &sb));
+  close(fd);
+}
diff --git a/tests/statvfs_test.cpp b/tests/sys_statvfs_test.cpp
index 1afb9c673..6b19e13b8 100644
--- a/tests/statvfs_test.cpp
+++ b/tests/sys_statvfs_test.cpp
@@ -24,12 +24,7 @@
 
 #include <string>
 
-TEST(statvfs, statvfs) {
-  struct statvfs sb;
-  memset(&sb, 0, sizeof(sb));
-
-  ASSERT_EQ(0, statvfs("/proc", &sb));
-
+template <typename StatVfsT> void Check(StatVfsT& sb) {
   EXPECT_EQ(4096U, sb.f_bsize);
   EXPECT_EQ(0U, sb.f_bfree);
   EXPECT_EQ(0U, sb.f_ffree);
@@ -37,17 +32,29 @@ TEST(statvfs, statvfs) {
   EXPECT_EQ(255U, sb.f_namemax);
 }
 
-TEST(statvfs, fstatvfs) {
+TEST(sys_statvfs, statvfs) {
   struct statvfs sb;
-  memset(&sb, 0, sizeof(sb));
+  ASSERT_EQ(0, statvfs("/proc", &sb));
+  Check(sb);
+}
+
+TEST(sys_statvfs, statvfs64) {
+  struct statvfs64 sb;
+  ASSERT_EQ(0, statvfs64("/proc", &sb));
+  Check(sb);
+}
 
+TEST(sys_statvfs, fstatvfs) {
+  struct statvfs sb;
   int fd = open("/proc", O_RDONLY);
   ASSERT_EQ(0, fstatvfs(fd, &sb));
   close(fd);
-
-  EXPECT_EQ(4096U, sb.f_bsize);
-  EXPECT_EQ(0U, sb.f_bfree);
-  EXPECT_EQ(0U, sb.f_ffree);
-  EXPECT_EQ(0U, sb.f_fsid);
-  EXPECT_EQ(255U, sb.f_namemax);
+  Check(sb);
+}
+TEST(sys_statvfs, fstatvfs64) {
+  struct statvfs64 sb;
+  int fd = open("/proc", O_RDONLY);
+  ASSERT_EQ(0, fstatvfs64(fd, &sb));
+  close(fd);
+  Check(sb);
 }