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_ANDROID)
+// For Android, we use ashmem to implement SharedMemory. ashmem_create_region
+// will automatically pin the region. We never explicitly call pin/unpin. When
+// all the file descriptors from different processes associated with the region
+// are closed, the memory buffer will go away.
+#include "third_party/ashmem/ashmem.h"
+#endif
+
 #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";
@@ skipping 66 matching lines @@
 }
 
 // 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) {
+#if defined(OS_ANDROID)

[darin (slow to review), 2011/06/17 16:29:29]

it seems like almost all of the code in this file is #ifdef'd differently for
android.  maybe there is a better way to factor things so that the code is less
chopped up?  maybe shared_memroy_android.cc would make sense?

[michaelbai, 2011/06/17 22:41:29]

I moved fully android specific methods into shared_memory_android.c, but can not
completely get ride of android specific code from this file because android
still need share some posix code.

+  DCHECK(mapped_file_ == -1);

[joth, 2011/06/17 11:25:54]

DCHECK_EQ(-1, mapped_file_)

[michaelbai, 2011/06/17 22:41:29]

Done.

+
+  // "name" is just a label in ashmem. It is visible in /proc/pid/maps.
+  mapped_file_ = ashmem_create_region(name.data(), size);

[joth, 2011/06/17 11:25:54]

name.c_str(), to ensure it is null terminated

[michaelbai, 2011/06/17 22:41:29]

Done, thanks

+  if (-1 == mapped_file_) {
+    LOG(ERROR) << "Shared memory creation failed";

[darin (slow to review), 2011/06/17 16:29:29]

nit: do you really need these log statements to be compiled into release mode? 
wouldn't DLOG suffice?

[michaelbai, 2011/06/17 22:41:29]

Done.

+    return false;
+  }
+
+  int err = ashmem_set_prot_region(mapped_file_,
+                                   PROT_READ | PROT_WRITE | PROT_EXEC);
+  if (err < 0) {
+    LOG(ERROR) << "Error " << err << " when setting protection of ashmem";
+    return false;
+  }
+  created_size_ = size;
+
+  return true;
+#else
   DCHECK_EQ(-1, mapped_file_);
   if (size == 0) 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 *fp;
   bool fix_size = true;
@@ skipping 48 matching lines @@
         << "/dev/shm.  Try 'sudo chmod 1777 /dev/shm' to fix.";
       }
     }
 #else
     PLOG(ERROR) << "Creating shared memory in " << path.value() << " failed";
 #endif
     return false;
   }
 
   return PrepareMapFile(fp);
+#endif  // defined(OS_ANDROID)
 }
 
 // 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) {
+#if defined(OS_ANDROID)
+  // ashmem doesn't support name mapping
+  NOTIMPLEMENTED();
+  return false;
+#endif
+
   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;
 
+#if defined(OS_ANDROID)
+  // ashmem doesn't support name mapping
+  NOTIMPLEMENTED();
+  return false;
+#endif
+
   const char *mode = read_only ? "r" : "r+";
   FILE *fp = file_util::OpenFile(path, mode);
   return PrepareMapFile(fp);
 }
 
 bool SharedMemory::Map(uint32 bytes) {
   if (mapped_file_ == -1)
     return false;
 
+#if defined(OS_ANDROID)
+  const uint32 ashmem_bytes = ashmem_get_size_region(mapped_file_);

[joth, 2011/06/17 11:25:54]

ashmem_get_size_region appears to return 'int', probably best to use that here
too

[michaelbai, 2011/06/17 22:41:29]

Done.

+  DCHECK_GE(ashmem_bytes, bytes);
+  if (bytes == 0) {
+    // The caller wants to determine the map region size from ashmem.
+    bytes = ashmem_bytes;
+    // HACK: we set the created size here so that it is available in
+    // transport_dib_android.cc. Other choices would be to add an accessor to
+    // mapped_size_ (apparently undesirable, see the comment for created_size()
+    // in shared_memory.h) or to duplicate the ashmem_get_size_region call above
+    // in TransportDIB::Map().

[joth, 2011/06/17 11:25:54]

can we fix this? It seems to be abusing both Map(0) and created_size()
see also bug http://crbug.com/60821 - that seems to suggest TransportDIB should
just keep track itself of the size it requested
just calling ashmem_get_size_region in transport_dib_android doesn't sound
awful, but if it is, how about we could always add a dedicated OS_ANDROID only
function onto SharedMemory to do what we need.
SharedMemory::GetAshmenSizeRegion()

[michaelbai, 2011/06/17 22:41:29]

Method added, I will have another CL to handle the reset of change.  

+    created_size_ = bytes;
+  }
+#endif
+
   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 15 matching lines @@
 void SharedMemory::Close() {
   Unmap();
 
   if (mapped_file_ > 0) {
     if (HANDLE_EINTR(close(mapped_file_)) < 0)
       PLOG(ERROR) << "close";
     mapped_file_ = -1;
   }
 }
 
+// The lockf() function is not available on Android; we translate to flock().
+#if defined(OS_ANDROID)
+#define F_LOCK LOCK_EX
+#define F_ULOCK LOCK_UN
+static inline int lockf(int fd, int cmd, off_t ignored_len) {

[joth, 2011/06/17 11:25:54]

nit: use anon namespace rather than static (unless we want to ensure a build
break should it get added to android in future?)

also why here? Maybe better up top of file (with any other related platform
functions)

[michaelbai, 2011/06/17 22:41:29]

Done.

+  return flock(fd, cmd);
+}
+#endif
+
+
 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