Thread IO safety: file_util annotated, IO thread blocked from doing IO

base/file_util_posix.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/file_util.h"
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <fnmatch.h>
@@ skipping 21 matching lines @@
 
 #include "base/basictypes.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/lock.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
+#include "base/thread_restrictions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 
 namespace file_util {
 
 namespace {
 
 // Helper for NormalizeFilePath(), defined below.
 bool RealPath(const FilePath& path, FilePath* real_path) {
+  base::ThreadRestrictions::AssertIOAllowed();  // For realpath().
   FilePath::CharType buf[PATH_MAX];
   if (!realpath(path.value().c_str(), buf))
     return false;
 
   *real_path = FilePath(buf);
   return true;
 }
 
 }  // namespace
 
 #if defined(OS_OPENBSD) || defined(OS_FREEBSD) || \
     (defined(OS_MACOSX) && \
      MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5)
 typedef struct stat stat_wrapper_t;
 static int CallStat(const char *path, stat_wrapper_t *sb) {
+  base::ThreadRestrictions::AssertIOAllowed();
   return stat(path, sb);
 }
 #else
 typedef struct stat64 stat_wrapper_t;
 static int CallStat(const char *path, stat_wrapper_t *sb) {
+  base::ThreadRestrictions::AssertIOAllowed();
   return stat64(path, sb);
 }
 #endif
 
 
 #if defined(GOOGLE_CHROME_BUILD)
 static const char* kTempFileName = ".com.google.chrome.XXXXXX";
 #else
 static const char* kTempFileName = ".org.chromium.XXXXXX";
 #endif
 
 bool AbsolutePath(FilePath* path) {
+  base::ThreadRestrictions::AssertIOAllowed();  // For realpath().
   char full_path[PATH_MAX];
   if (realpath(path->value().c_str(), full_path) == NULL)
     return false;
   *path = FilePath(full_path);
   return true;
 }
 
 int CountFilesCreatedAfter(const FilePath& path,
                            const base::Time& comparison_time) {
+  base::ThreadRestrictions::AssertIOAllowed();
   int file_count = 0;
 
   DIR* dir = opendir(path.value().c_str());
   if (dir) {
 #if !defined(OS_LINUX) && !defined(OS_MACOSX) && !defined(OS_FREEBSD) && \
     !defined(OS_OPENBSD) && !defined(OS_SOLARIS)
   #error Port warning: depending on the definition of struct dirent, \
          additional space for pathname may be needed
 #endif
     struct dirent ent_buf;
@@ skipping 30 matching lines @@
     closedir(dir);
   }
   return file_count;
 }
 
 // TODO(erikkay): The Windows version of this accepts paths like "foo/bar/*"
 // which works both with and without the recursive flag.  I'm not sure we need
 // that functionality. If not, remove from file_util_win.cc, otherwise add it
 // here.
 bool Delete(const FilePath& path, bool recursive) {
+  base::ThreadRestrictions::AssertIOAllowed();
   const char* path_str = path.value().c_str();
   stat_wrapper_t file_info;
   int test = CallStat(path_str, &file_info);
   if (test != 0) {
     // The Windows version defines this condition as success.
     bool ret = (errno == ENOENT || errno == ENOTDIR);
     return ret;
   }
   if (!S_ISDIR(file_info.st_mode))
     return (unlink(path_str) == 0);
@@ skipping 19 matching lines @@
 
   while (success && !directories.empty()) {
     FilePath dir = FilePath(directories.top());
     directories.pop();
     success = (rmdir(dir.value().c_str()) == 0);
   }
   return success;
 }
 
 bool Move(const FilePath& from_path, const FilePath& to_path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   // Windows compatibility: if to_path exists, from_path and to_path
   // must be the same type, either both files, or both directories.
   stat_wrapper_t to_file_info;
   if (CallStat(to_path.value().c_str(), &to_file_info) == 0) {
     stat_wrapper_t from_file_info;
     if (CallStat(from_path.value().c_str(), &from_file_info) == 0) {
       if (S_ISDIR(to_file_info.st_mode) != S_ISDIR(from_file_info.st_mode))
         return false;
     } else {
       return false;
     }
   }
 
   if (rename(from_path.value().c_str(), to_path.value().c_str()) == 0)
     return true;
 
   if (!CopyDirectory(from_path, to_path, true))
     return false;
 
   Delete(from_path, true);
   return true;
 }
 
 bool ReplaceFile(const FilePath& from_path, const FilePath& to_path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   return (rename(from_path.value().c_str(), to_path.value().c_str()) == 0);
 }
 
 bool CopyDirectory(const FilePath& from_path,
                    const FilePath& to_path,
                    bool recursive) {
+  base::ThreadRestrictions::AssertIOAllowed();
   // Some old callers of CopyDirectory want it to support wildcards.
   // After some discussion, we decided to fix those callers.
   // Break loudly here if anyone tries to do this.
   // TODO(evanm): remove this once we're sure it's ok.
   DCHECK(to_path.value().find('*') == std::string::npos);
   DCHECK(from_path.value().find('*') == std::string::npos);
 
   char top_dir[PATH_MAX];
   if (base::strlcpy(top_dir, from_path.value().c_str(),
                     arraysize(top_dir)) >= arraysize(top_dir)) {
@@ skipping 79 matching lines @@
     }
 
     current = traversal.Next();
     traversal.GetFindInfo(&info);
   }
 
   return success;
 }
 
 bool PathExists(const FilePath& path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   return access(path.value().c_str(), F_OK) == 0;
 }
 
 bool PathIsWritable(const FilePath& path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   return access(path.value().c_str(), W_OK) == 0;
 }
 
 bool DirectoryExists(const FilePath& path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   stat_wrapper_t file_info;
   if (CallStat(path.value().c_str(), &file_info) == 0)
     return S_ISDIR(file_info.st_mode);
   return false;
 }
 
 // TODO(erikkay): implement
 #if 0
 bool GetFileCreationLocalTimeFromHandle(int fd,
                                         LPSYSTEMTIME creation_time) {
@@ skipping 30 matching lines @@
       break;
     total_read += bytes_read;
   }
   return total_read == bytes;
 }
 
 // Creates and opens a temporary file in |directory|, returning the
 // file descriptor. |path| is set to the temporary file path.
 // This function does NOT unlink() the file.
 int CreateAndOpenFdForTemporaryFile(FilePath directory, FilePath* path) {
+  base::ThreadRestrictions::AssertIOAllowed();  // For call to mkstemp().
   *path = directory.Append(kTempFileName);
   const std::string& tmpdir_string = path->value();
   // this should be OK since mkstemp just replaces characters in place
   char* buffer = const_cast<char*>(tmpdir_string.c_str());
 
   return mkstemp(buffer);
 }
 
 bool CreateTemporaryFile(FilePath* path) {
+  base::ThreadRestrictions::AssertIOAllowed();  // For call to close().
   FilePath directory;
   if (!GetTempDir(&directory))
     return false;
   int fd = CreateAndOpenFdForTemporaryFile(directory, path);
   if (fd < 0)
     return false;
   close(fd);
   return true;
 }
 
 FILE* CreateAndOpenTemporaryShmemFile(FilePath* path) {
   FilePath directory;
   if (!GetShmemTempDir(&directory))
     return NULL;
 
   return CreateAndOpenTemporaryFileInDir(directory, path);
 }
 
 FILE* CreateAndOpenTemporaryFileInDir(const FilePath& dir, FilePath* path) {
   int fd = CreateAndOpenFdForTemporaryFile(dir, path);
   if (fd < 0)
     return NULL;
 
   return fdopen(fd, "a+");
 }
 
 bool CreateTemporaryFileInDir(const FilePath& dir, FilePath* temp_file) {
+  base::ThreadRestrictions::AssertIOAllowed();  // For call to close().
   int fd = CreateAndOpenFdForTemporaryFile(dir, temp_file);
   return ((fd >= 0) && !close(fd));
 }
 
 static bool CreateTemporaryDirInDirImpl(const FilePath& base_dir,
                                         const FilePath::StringType& name_tmpl,
                                         FilePath* new_dir) {
+  base::ThreadRestrictions::AssertIOAllowed();  // For call to mkdtemp().
   CHECK(name_tmpl.find("XXXXXX") != FilePath::StringType::npos)
     << "Directory name template must contain \"XXXXXX\".";
 
   FilePath sub_dir = base_dir.Append(name_tmpl);
   std::string sub_dir_string = sub_dir.value();
 
   // this should be OK since mkdtemp just replaces characters in place
   char* buffer = const_cast<char*>(sub_dir_string.c_str());
   char* dtemp = mkdtemp(buffer);
   if (!dtemp) {
@@ skipping 15 matching lines @@
 bool CreateNewTempDirectory(const FilePath::StringType& prefix,
                             FilePath* new_temp_path) {
   FilePath tmpdir;
   if (!GetTempDir(&tmpdir))
     return false;
 
   return CreateTemporaryDirInDirImpl(tmpdir, kTempFileName, new_temp_path);
 }
 
 bool CreateDirectory(const FilePath& full_path) {
+  base::ThreadRestrictions::AssertIOAllowed();  // For call to mkdir().
   std::vector<FilePath> subpaths;
 
   // Collect a list of all parent directories.
   FilePath last_path = full_path;
   subpaths.push_back(full_path);
   for (FilePath path = full_path.DirName();
        path.value() != last_path.value(); path = path.DirName()) {
     subpaths.push_back(path);
     last_path = path;
   }
@@ skipping 21 matching lines @@
     return false;
   results->is_directory = S_ISDIR(file_info.st_mode);
   results->size = file_info.st_size;
   results->last_modified = base::Time::FromTimeT(file_info.st_mtime);
   results->last_accessed = base::Time::FromTimeT(file_info.st_atime);
   results->creation_time = base::Time::FromTimeT(file_info.st_ctime);
   return true;
 }
 
 bool GetInode(const FilePath& path, ino_t* inode) {
+  base::ThreadRestrictions::AssertIOAllowed();  // For call to stat().
   struct stat buffer;
   int result = stat(path.value().c_str(), &buffer);
   if (result < 0)
     return false;
 
   *inode = buffer.st_ino;
   return true;
 }
 
 FILE* OpenFile(const std::string& filename, const char* mode) {
   return OpenFile(FilePath(filename), mode);
 }
 
 FILE* OpenFile(const FilePath& filename, const char* mode) {
+  base::ThreadRestrictions::AssertIOAllowed();
   return fopen(filename.value().c_str(), mode);
 }
 
 int ReadFile(const FilePath& filename, char* data, int size) {
+  base::ThreadRestrictions::AssertIOAllowed();
   int fd = open(filename.value().c_str(), O_RDONLY);
   if (fd < 0)
     return -1;
 
   ssize_t bytes_read = HANDLE_EINTR(read(fd, data, size));
   if (int ret = HANDLE_EINTR(close(fd)) < 0)
     return ret;
   return bytes_read;
 }
 
 int WriteFile(const FilePath& filename, const char* data, int size) {
+  base::ThreadRestrictions::AssertIOAllowed();
   int fd = creat(filename.value().c_str(), 0666);
   if (fd < 0)
     return -1;
 
   int bytes_written = WriteFileDescriptor(fd, data, size);
   if (int ret = HANDLE_EINTR(close(fd)) < 0)
     return ret;
   return bytes_written;
 }
 
 int WriteFileDescriptor(const int fd, const char* data, int size) {
   // Allow for partial writes.
   ssize_t bytes_written_total = 0;
   for (ssize_t bytes_written_partial = 0; bytes_written_total < size;
        bytes_written_total += bytes_written_partial) {
     bytes_written_partial =
         HANDLE_EINTR(write(fd, data + bytes_written_total,
                            size - bytes_written_total));
     if (bytes_written_partial < 0)
       return -1;
   }
 
   return bytes_written_total;
 }
 
 // Gets the current working directory for the process.
 bool GetCurrentDirectory(FilePath* dir) {
+  // getcwd can return ENOENT, which implies it checks against the disk.
+  base::ThreadRestrictions::AssertIOAllowed();
+
   char system_buffer[PATH_MAX] = "";
   if (!getcwd(system_buffer, sizeof(system_buffer))) {
     NOTREACHED();
     return false;
   }
   *dir = FilePath(system_buffer);
   return true;
 }
 
 // Sets the current working directory for the process.
 bool SetCurrentDirectory(const FilePath& path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   int ret = chdir(path.value().c_str());
   return !ret;
 }
 
 ///////////////////////////////////////////////
 // FileEnumerator
 
 FileEnumerator::FileEnumerator(const FilePath& root_path,
                                bool recursive,
                                FileEnumerator::FILE_TYPE file_type)
@@ skipping 84 matching lines @@
         directory_entries_.push_back(*i);
     }
   }
 
   return root_path_.Append(directory_entries_[current_directory_entry_
       ].filename);
 }
 
 bool FileEnumerator::ReadDirectory(std::vector<DirectoryEntryInfo>* entries,
                                    const FilePath& source, bool show_links) {
+  base::ThreadRestrictions::AssertIOAllowed();
   DIR* dir = opendir(source.value().c_str());
   if (!dir)
     return false;
 
 #if !defined(OS_LINUX) && !defined(OS_MACOSX) && !defined(OS_FREEBSD) && \
     !defined(OS_OPENBSD) && !defined(OS_SOLARIS)
   #error Port warning: depending on the definition of struct dirent, \
          additional space for pathname may be needed
 #endif
 
@@ skipping 28 matching lines @@
 ///////////////////////////////////////////////
 // MemoryMappedFile
 
 MemoryMappedFile::MemoryMappedFile()
     : file_(base::kInvalidPlatformFileValue),
       data_(NULL),
       length_(0) {
 }
 
 bool MemoryMappedFile::MapFileToMemoryInternal() {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   struct stat file_stat;
   if (fstat(file_, &file_stat) == base::kInvalidPlatformFileValue) {
     LOG(ERROR) << "Couldn't fstat " << file_ << ", errno " << errno;
     return false;
   }
   length_ = file_stat.st_size;
 
   data_ = static_cast<uint8*>(
       mmap(NULL, length_, PROT_READ, MAP_SHARED, file_, 0));
   if (data_ == MAP_FAILED)
     LOG(ERROR) << "Couldn't mmap " << file_ << ", errno " << errno;
 
   return data_ != MAP_FAILED;
 }
 
 void MemoryMappedFile::CloseHandles() {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   if (data_ != NULL)
     munmap(data_, length_);
   if (file_ != base::kInvalidPlatformFileValue)
     close(file_);
 
   data_ = NULL;
   length_ = 0;
   file_ = base::kInvalidPlatformFileValue;
 }
 
@@ skipping 31 matching lines @@
 bool GetShmemTempDir(FilePath* path) {
   *path = FilePath("/dev/shm");
   return true;
 }
 
 FilePath GetHomeDir() {
   const char* home_dir = getenv("HOME");
   if (home_dir && home_dir[0])
     return FilePath(home_dir);
 
+  // g_get_home_dir calls getpwent, which can fall through to LDAP calls.
+  base::ThreadRestrictions::AssertIOAllowed();
+
   home_dir = g_get_home_dir();
   if (home_dir && home_dir[0])
     return FilePath(home_dir);
 
   FilePath rv;
   if (file_util::GetTempDir(&rv))
     return rv;
 
   // Last resort.
   return FilePath("/tmp");
 }
 
 bool CopyFile(const FilePath& from_path, const FilePath& to_path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   int infile = open(from_path.value().c_str(), O_RDONLY);
   if (infile < 0)
     return false;
 
   int outfile = creat(to_path.value().c_str(), 0666);
   if (outfile < 0) {
     close(infile);
     return false;
   }
 
@@ skipping 27 matching lines @@
   if (HANDLE_EINTR(close(infile)) < 0)
     result = false;
   if (HANDLE_EINTR(close(outfile)) < 0)
     result = false;
 
   return result;
 }
 #endif  // defined(OS_MACOSX)
 
 } // namespace file_util