Upstream android file related code.

base/shared_memory_posix.cc

 // Copyright (c) 2011 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/shared_memory.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/threading/platform_thread.h"
 #include "base/safe_strerror_posix.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/foundation_util.h"
 #endif  // OS_MACOSX
 
 namespace base {
 
 namespace {
+
 // Paranoia. Semaphores and shared memory segments should live in different
 // namespaces, but who knows what's out there.
 const char kSemaphoreSuffix[] = "-sem";
+
+#if defined(OS_ANDROID)
+// The lockf() function is not available on Android; we translate to flock().
+#define F_LOCK LOCK_EX
+#define F_ULOCK LOCK_UN
+inline int lockf(int fd, int cmd, off_t ignored_len) {
+  return flock(fd, cmd);
 }
+#endif
+
+}  // namespace.
 
 SharedMemory::SharedMemory()
     : mapped_file_(-1),
       mapped_size_(0),
       inode_(0),
       memory_(NULL),
       read_only_(false),
       created_size_(0) {
 }
 
@@ skipping 47 matching lines @@
 }
 
 bool SharedMemory::CreateAndMapAnonymous(uint32 size) {
   return CreateAnonymous(size) && Map(size);
 }
 
 bool SharedMemory::CreateAnonymous(uint32 size) {
   return CreateNamed("", false, size);
 }
 
+#if !defined(OS_ANDROID)
 // Chromium mostly only uses the unique/private shmem as specified by
 // "name == L"". The exception is in the StatsTable.
 // TODO(jrg): there is no way to "clean up" all unused named shmem if
 // we restart from a crash.  (That isn't a new problem, but it is a problem.)
 // In case we want to delete it later, it may be useful to save the value
 // of mem_filename after FilePathForMemoryName().
 bool SharedMemory::CreateNamed(const std::string& name,
                                bool open_existing, uint32 size) {
   DCHECK_EQ(-1, mapped_file_);
   if (size == 0) return false;
@@ skipping 62 matching lines @@
     return false;
   }
 
   return PrepareMapFile(fp);
 }
 
 // Our current implementation of shmem is with mmap()ing of files.
 // These files need to be deleted explicitly.
 // In practice this call is only needed for unit tests.
 bool SharedMemory::Delete(const std::string& name) {
+

[joth, 2011/06/19 12:48:05]

nit: remove \n

[michaelbai, 2011/06/20 22:50:36]

Done.

   FilePath path;
   if (!FilePathForMemoryName(name, &path))
     return false;
 
   if (file_util::PathExists(path)) {
     return file_util::Delete(path, false);
   }
 
   // Doesn't exist, so success.
   return true;
 }
 
 bool SharedMemory::Open(const std::string& name, bool read_only) {
   FilePath path;
   if (!FilePathForMemoryName(name, &path))
     return false;
 
   read_only_ = read_only;
 
   const char *mode = read_only ? "r" : "r+";
   FILE *fp = file_util::OpenFile(path, mode);
   return PrepareMapFile(fp);
 }
 
+#endif  // !defined(OS_ANDROID)
+
 bool SharedMemory::Map(uint32 bytes) {
   if (mapped_file_ == -1)
     return false;
 
+#if defined(OS_ANDROID)
+  int ashmem_bytes = GetAshmenSizeRegion();
+  DCHECK_GE((uint32)ashmem_bytes, bytes);

[joth, 2011/06/19 12:48:05]

nit: static_cast<uint32>(ashmem_bytes) although this check will be ineffective
if GetAshmenSizeRegion returns -1
-> should check for negative return value and return false(?)
-> could the GetAshmenSizeRegion() call not go inside the if (bytes == 0) below?

[michaelbai, 2011/06/20 22:50:36]

Done.

+  if (bytes == 0) {
+    // The caller wants to determine the map region size from ashmem.
+    bytes = ashmem_bytes;
+    // TODO(port): we set the created size here so that it is available in
+    // transport_dib_android.cc. We should use
+    // SharedMemory::GetAshmenSizeRegion() in TransportDIB::Map().
+    created_size_ = bytes;
+  }
+#endif

[joth, 2011/06/19 12:48:05]

seems unfortunate to commit this hack when the code depending on it is can be
fixed before being committed itself, but there we go.

+
   memory_ = mmap(NULL, bytes, PROT_READ | (read_only_ ? 0 : PROT_WRITE),
                  MAP_SHARED, mapped_file_, 0);
 
   if (memory_)
     mapped_size_ = bytes;
 
   bool mmap_succeeded = (memory_ != (void*)-1);
   DCHECK(mmap_succeeded) << "Call to mmap failed, errno=" << errno;
   return mmap_succeeded;
 }
@@ skipping 23 matching lines @@
 }
 
 void SharedMemory::Lock() {
   LockOrUnlockCommon(F_LOCK);
 }
 
 void SharedMemory::Unlock() {
   LockOrUnlockCommon(F_ULOCK);
 }
 
+#if !defined(OS_ANDROID)
 bool SharedMemory::PrepareMapFile(FILE *fp) {
   DCHECK_EQ(-1, mapped_file_);
   if (fp == NULL) return false;
 
   // This function theoretically can block on the disk, but realistically
   // the temporary files we create will just go into the buffer cache
   // and be deleted before they ever make it out to disk.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   file_util::ScopedFILE file_closer(fp);
 
   mapped_file_ = dup(fileno(fp));
   if (mapped_file_ == -1) {
     if (errno == EMFILE) {
       LOG(WARNING) << "Shared memory creation failed; out of file descriptors";
       return false;
     } else {
       NOTREACHED() << "Call to dup failed, errno=" << errno;
     }
   }
 
   struct stat st;
   if (fstat(mapped_file_, &st))
     NOTREACHED();
   inode_ = st.st_ino;
 
   return true;
 }
+#endif
 
 // For the given shmem named |mem_name|, return a filename to mmap()
 // (and possibly create).  Modifies |filename|.  Return false on
 // error, or true of we are happy.
 bool SharedMemory::FilePathForMemoryName(const std::string& mem_name,
                                          FilePath* path) {
   // mem_name will be used for a filename; make sure it doesn't
   // contain anything which will confuse us.
   DCHECK_EQ(std::string::npos, mem_name.find('/'));
   DCHECK_EQ(std::string::npos, mem_name.find('\0'));
@@ skipping 42 matching lines @@
   new_handle->fd = new_fd;
   new_handle->auto_close = true;
 
   if (close_self)
     Close();
 
   return true;
 }
 
 }  // namespace base