mojo/nacl/mojo_syscall_internal.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MOJO_NACL_MOJO_SYSCALL_INTERNAL_H_
   6 #define MOJO_NACL_MOJO_SYSCALL_INTERNAL_H_
   7
   8 #include "native_client/src/trusted/service_runtime/nacl_copy.h"
   9 #include "native_client/src/trusted/service_runtime/sel_ldr.h"
  10
  11 namespace {
  12
  13 class ScopedCopyLock {
  14  public:
  15   explicit ScopedCopyLock(struct NaClApp* nap) : nap_(nap) {
  16     NaClCopyTakeLock(nap_);
  17   }
  18   ~ScopedCopyLock() {
  19     NaClCopyDropLock(nap_);
  20   }
  21  private:
  22   struct NaClApp* nap_;
  23 };
  24
  25 static inline uintptr_t NaClUserToSysAddrArray(
  26     struct NaClApp* nap,
  27     uint32_t uaddr,
  28     size_t count,
  29     size_t size) {
  30   // TODO(ncbray): overflow checking
  31   size_t range = count * size;
  32   return NaClUserToSysAddrRange(nap, uaddr, range);
  33 }
  34
  35 template <typename T> bool ConvertScalarInput(
  36     struct NaClApp* nap,
  37     uint32_t user_ptr,
  38     T* value) {
  39   if (user_ptr) {
  40     uintptr_t temp = NaClUserToSysAddrRange(nap, user_ptr, sizeof(T));
  41     if (temp != kNaClBadAddress) {
  42       *value = *reinterpret_cast<T volatile*>(temp);
  43       return true;
  44     }
  45   }
  46   return false;
  47 }
  48
  49 template <typename T> bool ConvertScalarOutput(
  50     struct NaClApp* nap,
  51     uint32_t user_ptr,
  52     T volatile** sys_ptr) {
  53   if (user_ptr) {
  54     uintptr_t temp = NaClUserToSysAddrRange(nap, user_ptr, sizeof(T));
  55     if (temp != kNaClBadAddress) {
  56       *sys_ptr = reinterpret_cast<T volatile*>(temp);
  57       return true;
  58     }
  59   }
  60   *sys_ptr = 0; // Paranoia.
  61   return false;
  62 }
  63
  64 template <typename T> bool ConvertScalarInOut(
  65     struct NaClApp* nap,
  66     uint32_t user_ptr,
  67     bool optional,
  68     T* value,
  69     T volatile** sys_ptr) {
  70   if (user_ptr) {
  71     uintptr_t temp = NaClUserToSysAddrRange(nap, user_ptr, sizeof(T));
  72     if (temp != kNaClBadAddress) {
  73       T volatile* converted = reinterpret_cast<T volatile*>(temp);
  74       *sys_ptr = converted;
  75       *value = *converted;
  76       return true;
  77     }
  78   } else if (optional) {
  79     *sys_ptr = 0;
  80     *value = static_cast<T>(0); // Paranoia.
  81     return true;
  82   }
  83   *sys_ptr = 0; // Paranoia.
  84   *value = static_cast<T>(0); // Paranoia.
  85   return false;
  86 }
  87
  88 template <typename T> bool ConvertArray(
  89     struct NaClApp* nap,
  90     uint32_t user_ptr,
  91     uint32_t length,
  92     size_t element_size,
  93     bool optional,
  94     T** sys_ptr) {
  95   if (user_ptr) {
  96     uintptr_t temp = NaClUserToSysAddrArray(nap, user_ptr, length,
  97                                             element_size);
  98     if (temp != kNaClBadAddress) {
  99       *sys_ptr = reinterpret_cast<T*>(temp);
 100       return true;
 101     }
 102   } else if (optional) {
 103     *sys_ptr = 0;
 104     return true;
 105   }
 106   return false;
 107 }
 108
 109 template <typename T> bool ConvertBytes(
 110     struct NaClApp* nap,
 111     uint32_t user_ptr,
 112     uint32_t length,
 113     bool optional,
 114     T** sys_ptr) {
 115   if (user_ptr) {
 116     uintptr_t temp = NaClUserToSysAddrRange(nap, user_ptr, length);
 117     if (temp != kNaClBadAddress) {
 118       *sys_ptr = reinterpret_cast<T*>(temp);
 119       return true;
 120     }
 121   } else if (optional) {
 122     *sys_ptr = 0;
 123     return true;
 124   }
 125   return false;
 126 }
 127
 128 // TODO(ncbray): size validation and complete copy.
 129 // TODO(ncbray): ensure non-null / missized structs are covered by a test case.
 130 template <typename T> bool ConvertStruct(
 131     struct NaClApp* nap,
 132     uint32_t user_ptr,
 133     bool optional,
 134     T** sys_ptr) {
 135   if (user_ptr) {
 136     uintptr_t temp = NaClUserToSysAddrRange(nap, user_ptr, sizeof(T));
 137     if (temp != kNaClBadAddress) {
 138       *sys_ptr = reinterpret_cast<T*>(temp);
 139       return true;
 140     }
 141   } else if (optional) {
 142     *sys_ptr = 0;
 143     return true;
 144   }
 145   return false;
 146 }
 147
 148 } // namespace
 149
 150 #endif // MOJO_NACL_MOJO_SYSCALL_INTERNAL_H_