Add a GUID to base::SharedMemoryHandle.

base/memory/shared_memory_posix.cc

 // Copyright (c) 2012 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/memory/shared_memory.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory_helper.h"
 #include "base/memory/shared_memory_tracker.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/safe_strerror.h"
 #include "base/process/process_metrics.h"
 #include "base/scoped_generic.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
+#include "base/unguessable_token.h"
 #include "build/build_config.h"
 
 #if defined(OS_ANDROID)
 #include "base/os_compat_android.h"
 #include "third_party/ashmem/ashmem.h"
 #endif
 
 namespace base {
 
 SharedMemory::SharedMemory()
@@ skipping 168 matching lines @@
                    << "/dev/shm.  Try 'sudo chmod 1777 /dev/shm' to fix.";
       }
     }
     return false;
   }
 
   int mapped_file = -1;
   int readonly_mapped_file = -1;
   bool result = PrepareMapFile(std::move(fp), std::move(readonly_fd),
                                &mapped_file, &readonly_mapped_file);
-  shm_ = SharedMemoryHandle::ImportHandle(mapped_file);
-  readonly_shm_ = SharedMemoryHandle::ImportHandle(readonly_mapped_file);
+  shm_ = SharedMemoryHandle(base::FileDescriptor(mapped_file, false),
+                            UnguessableToken::Create());
+  readonly_shm_ = SharedMemoryHandle(
+      base::FileDescriptor(readonly_mapped_file, false), shm_.GetGUID());
   return result;
 }
 
 // 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) {
   FilePath path;
   if (!FilePathForMemoryName(name, &path))
     return false;
@@ skipping 16 matching lines @@
   ScopedFILE fp(base::OpenFile(path, mode));
   ScopedFD readonly_fd(HANDLE_EINTR(open(path.value().c_str(), O_RDONLY)));
   if (!readonly_fd.is_valid()) {
     DPLOG(ERROR) << "open(\"" << path.value() << "\", O_RDONLY) failed";
     return false;
   }
   int mapped_file = -1;
   int readonly_mapped_file = -1;
   bool result = PrepareMapFile(std::move(fp), std::move(readonly_fd),
                                &mapped_file, &readonly_mapped_file);
-  shm_ = SharedMemoryHandle::ImportHandle(mapped_file);
-  readonly_shm_ = SharedMemoryHandle::ImportHandle(readonly_mapped_file);
+  // This form of sharing shared memory is deprecated. https://crbug.com/345734.
+  // However, we can't get rid of it without a significant refactor because its
+  // used to communicate between two versions of the same service process, very
+  // early in the life cycle.
+  // Technically, we should also pass the GUID from the original shared memory
+  // region. We don't do that - this means that we will overcount this memory,
+  // which thankfully isn't relevant since Chrome only communicates with a
+  // single version of the service process.
+  shm_ = SharedMemoryHandle(base::FileDescriptor(mapped_file, false),
+                            UnguessableToken::Create());
+  readonly_shm_ = SharedMemoryHandle(
+      base::FileDescriptor(readonly_mapped_file, false), shm_.GetGUID());
   return result;
 }
 #endif  // !defined(OS_ANDROID)
 
 bool SharedMemory::MapAt(off_t offset, size_t bytes) {
   if (!shm_.IsValid())
     return false;
 
   if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
     return false;
@@ skipping 108 matching lines @@
   struct stat file_stat;
   if (HANDLE_EINTR(
           ::fstat(static_cast<int>(handle().GetHandle()), &file_stat)) != 0)
     return false;
   id->first = file_stat.st_dev;
   id->second = file_stat.st_ino;
   return true;
 }
 
 }  // namespace base