Make SharedMemory track the size that was actually mapped

base/shared_memory_win.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 "base/logging.h"
 #include "base/utf_string_conversions.h"
 
+namespace {
+
+// Returns the length of the memory section starting at the supplied address.
+size_t GetMemorySectionSize(void* address) {
+  MEMORY_BASIC_INFORMATION memory_info;
+  if (!::VirtualQuery(address, &memory_info, sizeof(memory_info)))
+    return 0;
+  return memory_info.RegionSize - (static_cast<char*>(address) -
+         static_cast<char*>(memory_info.AllocationBase));
+}

[cpu_(ooo_6.6-7.5), 2013/03/21 17:14:22]

I only see one usage and it that case address == allocationBase, right?

Do you have other uses planned?

[jschuh, 2013/03/21 19:32:06]

Oh, there is only one use at this point so I can move it inline. However,
MapAt() doesn't need to align address to AllocationBase, and the cost of the
subtraction is negligible against the cost of mapping. So, I'd rather keep that
part, just to be safe.

[cpu_(ooo_6.6-7.5), 2013/03/21 20:06:15]

standalone is fine.

On 2013/03/21 19:32:06, Justin Schuh wrote:

+
+}  // namespace.
+
 namespace base {
 
 SharedMemory::SharedMemory()
     : mapped_file_(NULL),
       memory_(NULL),
       read_only_(false),
-      created_size_(0),
+      mapped_size_(0),
+      requested_size_(0),
       lock_(NULL) {
 }
 
 SharedMemory::SharedMemory(const std::wstring& name)
     : mapped_file_(NULL),
       memory_(NULL),
       read_only_(false),
-      created_size_(0),
+      requested_size_(0),
+      mapped_size_(0),
       lock_(NULL),
       name_(name) {
 }
 
 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only)
     : mapped_file_(handle),
       memory_(NULL),
       read_only_(read_only),
-      created_size_(0),
+      requested_size_(0),
+      mapped_size_(0),
       lock_(NULL) {
 }
 
 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only,
                            ProcessHandle process)
     : mapped_file_(NULL),
       memory_(NULL),
       read_only_(read_only),
-      created_size_(0),
+      requested_size_(0),
+      mapped_size_(0),
       lock_(NULL) {
   ::DuplicateHandle(process, handle,
                     GetCurrentProcess(), &mapped_file_,
                     STANDARD_RIGHTS_REQUIRED |
                     (read_only_ ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS),
                     FALSE, 0);
 }
 
 SharedMemory::~SharedMemory() {
   Close();
@@ skipping 15 matching lines @@
 void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
   DCHECK(handle != NULL);
   ::CloseHandle(handle);
 }
 
 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
   return CreateAnonymous(size) && Map(size);
 }
 
 bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
+  // TODO(bsy,sehr): crbug.com/210609 NaCl forces us to round up 64k here,
+  // wasting 32k per mapping on average.
+  static const size_t kSectionMask = 65536 - 1;
   DCHECK(!options.executable);
   DCHECK(!mapped_file_);
   if (options.size == 0)
     return false;
 
-  if (options.size > static_cast<size_t>(std::numeric_limits<int>::max()))
+  // Check maximum accounting for overflow.
+  if (options.size >
+      static_cast<size_t>(std::numeric_limits<int>::max()) - kSectionMask)
     return false;
 
-  // NaCl's memory allocator requires 0mod64K alignment and size for
-  // shared memory objects.  To allow passing shared memory to NaCl,
-  // therefore we round the size actually created to the nearest 64K unit.
-  // To avoid client impact, we continue to retain the size as the
-  // actual requested size.
-  uint32 rounded_size = (options.size + 0xffff) & ~0xffff;
-  if (rounded_size < options.size)
-    return false;
+  size_t rounded_size = (options.size + kSectionMask) & ~kSectionMask;
   name_ = ASCIIToWide(options.name == NULL ? "" : *options.name);
   mapped_file_ = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,
       PAGE_READWRITE, 0, static_cast<DWORD>(rounded_size),
       name_.empty() ? NULL : name_.c_str());
   if (!mapped_file_)
     return false;
 
-  created_size_ = options.size;
+  requested_size_ = options.size;
 
   // Check if the shared memory pre-exists.
   if (GetLastError() == ERROR_ALREADY_EXISTS) {
-    // If the file already existed, set created_size_ to 0 to show that
+    // If the file already existed, set requested_size_ to 0 to show that
     // we don't know the size.
-    created_size_ = 0;
+    requested_size_ = 0;
     if (!options.open_existing) {
       Close();
       return false;
     }
   }
 
   return true;
 }
 
 bool SharedMemory::Delete(const std::string& name) {
@@ skipping 24 matching lines @@
     return false;
 
   memory_ = MapViewOfFile(mapped_file_,
                           read_only_ ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS,
                           static_cast<uint64>(offset) >> 32,
                           static_cast<DWORD>(offset),
                           bytes);
   if (memory_ != NULL) {
     DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
         (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
+    mapped_size_ = GetMemorySectionSize(memory_);
     return true;
   }
   return false;
 }
 
 bool SharedMemory::Unmap() {
   if (memory_ == NULL)
     return false;
 
   UnmapViewOfFile(memory_);
@@ skipping 66 matching lines @@
 void SharedMemory::Unlock() {
   DCHECK(lock_ != NULL);
   ReleaseMutex(lock_);
 }
 
 SharedMemoryHandle SharedMemory::handle() const {
   return mapped_file_;
 }
 
 }  // namespace base