PPAPI: Implement PPB_FileMapping on POSIX

ppapi/proxy/file_mapping_resource.cc

Index: ppapi/proxy/file_mapping_resource.cc
diff --git a/ppapi/proxy/file_mapping_resource.cc b/ppapi/proxy/file_mapping_resource.cc
new file mode 100644
index 0000000000000000000000000000000000000000..85f22f04b08718e30e0d8ea884139d99ffa8a950
--- /dev/null
+++ b/ppapi/proxy/file_mapping_resource.cc
@@ -0,0 +1,209 @@
+// Copyright (c) 2013 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 "ppapi/proxy/file_mapping_resource.h"
+
+#if defined(OS_POSIX)
+#include <sys/mman.h>
+#include <unistd.h>
+#endif
+
+#include "base/bind.h"
+#include "base/safe_numerics.h"
+#include "base/task_runner_util.h"
+#include "ppapi/shared_impl/tracked_callback.h"
+#include "ppapi/shared_impl/var.h"
+#include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/ppb_file_io_api.h"
+
+namespace ppapi {
+namespace proxy {
+
+namespace {
+
+int32_t ErrnoToPPError(int error_code) {
+  switch (error_code) {
+    case EACCES:
+      return PP_ERROR_NOACCESS;
+    case EAGAIN:
+      return PP_ERROR_NOMEMORY;
+    case EINVAL:
+      return PP_ERROR_BADARGUMENT;
+    case ENFILE:
+    case ENOMEM:
+      return PP_ERROR_NOSPACE;
+    default:
+      return PP_ERROR_FAILED;
+  }
+}
+
+}
+
+FileMappingResource::FileMappingResource(Connection connection,
+                                         PP_Instance instance)
+    : PluginResource(connection, instance) {
+}
+
+FileMappingResource::~FileMappingResource() {
+}
+
+thunk::PPB_FileMapping_API* FileMappingResource::AsPPB_FileMapping_API() {
+  return this;
+}
+
+int32_t FileMappingResource::Map(PP_Instance /* instance */,
+                                 PP_Resource file_io,
+                                 int64_t length,
+                                 uint32_t map_protection,
+                                 uint32_t map_flags,
+                                 int64_t offset,
+                                 void** address,
+                                 scoped_refptr<TrackedCallback> callback) {
+  thunk::EnterResourceNoLock<thunk::PPB_FileIO_API> enter(file_io, true);
+  if (enter.failed())
+    return PP_ERROR_BADARGUMENT;
+  FileIOResource* file_io_resource =
+      static_cast<FileIOResource*>(enter.object());
+  scoped_refptr<FileIOResource::FileHandleHolder> file_handle =
+      file_io_resource->file_handle();
+  if (!FileIOResource::FileHandleHolder::IsValid(file_handle))
+    return PP_ERROR_BADARGUMENT;
+
+  if (length < 0 || offset < 0)
+    return PP_ERROR_BADARGUMENT;
+  // Ensure no bits that we don't recognize are set.
+  if (map_protection &
+      ~(PP_FILEMAPPROTECTION_READ | PP_FILEMAPPROTECTION_WRITE)) {
+    return PP_ERROR_BADARGUMENT;
+  }
+  if (map_flags &
+      ~(PP_FILEMAPFLAG_SHARED | PP_FILEMAPFLAG_PRIVATE |
+        PP_FILEMAPFLAG_FIXED)) {
+    return PP_ERROR_BADARGUMENT;
+  }
+  // Ensure at least one of SHARED and PRIVATE is set.
+  if (!(map_flags & (PP_FILEMAPFLAG_SHARED | PP_FILEMAPFLAG_PRIVATE)))
+    return PP_ERROR_BADARGUMENT;
+  // Ensure at most one of SHARED and PRIVATE is set.
+  if ((map_flags & PP_FILEMAPFLAG_SHARED) &&
+      (map_flags & PP_FILEMAPFLAG_PRIVATE)) {
+    return PP_ERROR_BADARGUMENT;
+  }
+  if (!address)
+    return PP_ERROR_BADARGUMENT;
+
+  base::Callback<MapResult()> map_op(
+      base::Bind(&FileMappingResource::DoMap, file_handle, *address, length,
+                 map_protection, map_flags, offset));
+  if (callback->is_blocking()) {
+    // The plugin could release its reference to this instance when we release
+    // the proxy lock below.
+    scoped_refptr<FileMappingResource> protect(this);
+    MapResult map_result;
+    {
+      // Release the proxy lock while making a potentially slow file call.
+      ProxyAutoUnlock unlock;
+      map_result = map_op.Run();
+    }
+    OnMapCompleted(address, callback, map_result);
+    return map_result.result;
+  } else {
+    base::PostTaskAndReplyWithResult(
+      PpapiGlobals::Get()->GetFileTaskRunner(),
+      FROM_HERE,
+      map_op,
+      RunWhileLocked(Bind(&FileMappingResource::OnMapCompleted,
+                          this,
+                          base::Unretained(address),
+                          callback)));
+    return PP_OK_COMPLETIONPENDING;
+  }
+}
+
+void FileMappingResource::Unmap(PP_Instance /* instance */,
+                                void* address,
+                                int64_t length) {
+  // TODO(dmichael): Is munmap slow enough that I should make this use a
+  // completion callback so it can run in the background? Noting that current
+  // known use-cases are all going to use it synchronously. Main reason for that
+  // would be so we can enforce that it's not done on the main thread.
+  // TODO(dmichael): Return something to indicate failure?
+#if defined(OS_POSIX)
+  munmap(address, base::checked_numeric_cast<size_t>(length));
+#else  // defined(OS_POSIX)
+  NOTREACHED();
+#endif
+}
+
+int64_t FileMappingResource::GetMapPageSize(PP_Instance /* instance */) {
+  // TODO(dmichael): It might be better to port sys_info_posix.cc to NaCl and
+  // call Sysinfo::VMAllocationGranularity.
+#if defined(OS_POSIX)
+  return getpagesize();
+#else  // defined(OS_POSIX)
+  NOTREACHED();
+  return 0;
+#endif
+}
+
+// static
+FileMappingResource::MapResult FileMappingResource::DoMap(
+    scoped_refptr<FileIOResource::FileHandleHolder> handle,
+    void* address_hint,
+    int64_t length,
+    uint32_t map_protection,
+    uint32_t map_flags,
+    int64_t offset) {
+#if defined(OS_POSIX)
+  int prot_for_mmap = 0;
+  if (map_protection & PP_FILEMAPPROTECTION_READ)
+    prot_for_mmap |= PROT_READ;
+  if (map_protection & PP_FILEMAPPROTECTION_WRITE)
+    prot_for_mmap |= PROT_WRITE;
+  if (prot_for_mmap == 0)
+    prot_for_mmap = PROT_NONE;
+
+  int flags_for_mmap = 0;
+  if (map_flags & PP_FILEMAPFLAG_SHARED)
+    flags_for_mmap |= MAP_SHARED;
+  if (map_flags & PP_FILEMAPFLAG_PRIVATE)
+    flags_for_mmap |= MAP_PRIVATE;
+  if (map_flags & PP_FILEMAPFLAG_FIXED)
+    flags_for_mmap |= MAP_FIXED;
+
+  MapResult map_result;
+  map_result.address =
+      mmap(address_hint,
+           base::checked_numeric_cast<size_t>(length),
+           prot_for_mmap,
+           flags_for_mmap,
+           handle->raw_handle(),
+           base::checked_numeric_cast<off_t>(offset));
+  if (map_result.address != MAP_FAILED)
+    map_result.result = PP_OK;
+  else
+    map_result.result = ErrnoToPPError(errno);
+#else  // defined(OS_POSIX)
+  // TODO(dmichael): Implement for Windows (crbug.com/83774).
+  NOTIMPLEMENTED();
+#endif
+  return MapResult();
+}
+
+void FileMappingResource::OnMapCompleted(
+    void** mapped_address_out_param,
+    scoped_refptr<TrackedCallback> callback,
+    const MapResult& map_result) {
+  // TODO(dmichael): If the callback is aborted, should we unmap?
+  if (callback->aborted())
+    return;
+  if (map_result.result == 0)
+    *mapped_address_out_param = map_result.address;
+  if (!callback->is_blocking())
+    callback->Run(map_result.result);
+}
+
+
+}  // namespace proxy
+}  // namespace ppapi