Ensure syscall functions are consistently prefixed with "NaClSys"

src/trusted/service_runtime/nacl_text.c

 /*
  * Copyright (c) 2012 The Native Client 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 <string.h>
 
 #include "native_client/src/include/concurrency_ops.h"
 #include "native_client/src/include/nacl_platform.h"
@@ skipping 708 matching lines @@
 
   retval = 0;
 
   NaClTextMapClearCacheIfNeeded(nap, dest, size);
 
  cleanup_unlock:
   NaClXMutexUnlock(&nap->dynamic_load_mutex);
   return retval;
 }
 
-int32_t NaClTextSysDyncodeCreate(struct NaClAppThread *natp,
-                                 uint32_t             dest,
-                                 uint32_t             src,
-                                 uint32_t             size) {
+int32_t NaClSysDyncodeCreate(struct NaClAppThread *natp,
+                             uint32_t             dest,
+                             uint32_t             src,
+                             uint32_t             size) {
   struct NaClApp              *nap = natp->nap;
   uintptr_t                   src_addr;
   uint8_t                     *code_copy;
   int32_t                     retval = -NACL_ABI_EINVAL;
 
   src_addr = NaClUserToSysAddrRange(nap, src, size);
   if (kNaClBadAddress == src_addr) {
-    NaClLog(1, "NaClTextSysDyncodeCreate: Source address out of range\n");
+    NaClLog(1, "NaClSysDyncodeCreate: Source address out of range\n");
     return -NACL_ABI_EFAULT;
   }
 
   /*
    * Make a private copy of the code, so that we can validate it
    * without a TOCTTOU race condition.
    */
   code_copy = malloc(size);
   if (NULL == code_copy) {
     return -NACL_ABI_ENOMEM;
   }
   memcpy(code_copy, (uint8_t*) src_addr, size);
 
   retval = NaClTextDyncodeCreate(nap, dest, code_copy, size);
 
   free(code_copy);
   return retval;
 }
 
-int32_t NaClTextSysDyncodeModify(struct NaClAppThread *natp,
-                                 uint32_t             dest,
-                                 uint32_t             src,
-                                 uint32_t             size) {
+int32_t NaClSysDyncodeModify(struct NaClAppThread *natp,
+                             uint32_t             dest,
+                             uint32_t             src,
+                             uint32_t             size) {
   struct NaClApp              *nap = natp->nap;
   uintptr_t                   dest_addr;
   uintptr_t                   src_addr;
   uintptr_t                   beginbundle;
   uintptr_t                   endbundle;
   uintptr_t                   offset;
   uint8_t                     *mapped_addr;
   uint8_t                     *code_copy = NULL;
   uint8_t                     code_copy_buf[NACL_INSTR_BLOCK_SIZE];
   int                         validator_result;
   int32_t                     retval = -NACL_ABI_EINVAL;
   struct NaClDynamicRegion    *region;
 
   if (NULL == nap->text_shm) {
-    NaClLog(1, "NaClTextSysDyncodeModify: Dynamic loading not enabled\n");
+    NaClLog(1, "NaClSysDyncodeModify: Dynamic loading not enabled\n");
     return -NACL_ABI_EINVAL;
   }
 
   if (0 == size) {
     /* Nothing to modify.  Succeed trivially. */
     return 0;
   }
 
   dest_addr = NaClUserToSysAddrRange(nap, dest, size);
   src_addr = NaClUserToSysAddrRange(nap, src, size);
   if (kNaClBadAddress == src_addr || kNaClBadAddress == dest_addr) {
-    NaClLog(1, "NaClTextSysDyncodeModify: Address out of range\n");
+    NaClLog(1, "NaClSysDyncodeModify: Address out of range\n");
     return -NACL_ABI_EFAULT;
   }
 
   NaClXMutexLock(&nap->dynamic_load_mutex);
 
   region = NaClDynamicRegionFind(nap, dest_addr, size);
   if (NULL == region || region->start > dest_addr
         || region->start + region->size < dest_addr + size) {
     /* target not a subregion of region or region is null */
-    NaClLog(1, "NaClTextSysDyncodeModify: Can't find region to modify\n");
+    NaClLog(1, "NaClSysDyncodeModify: Can't find region to modify\n");
     retval = -NACL_ABI_EFAULT;
     goto cleanup_unlock;
   }
 
   beginbundle = dest_addr & ~(nap->bundle_size - 1);
   endbundle   = (dest_addr + size - 1 + nap->bundle_size)
                   & ~(nap->bundle_size - 1);
   offset      = dest_addr &  (nap->bundle_size - 1);
   if (endbundle-beginbundle <= sizeof code_copy_buf) {
     /* usually patches are a single bundle, so stack allocate */
@@ skipping 31 matching lines @@
                                                  size);
 
   if (validator_result != LOAD_OK
       && nap->ignore_validator_result) {
     NaClLog(LOG_ERROR, "VALIDATION FAILED for dynamically-loaded code: "
                        "continuing anyway...\n");
     validator_result = LOAD_OK;
   }
 
   if (validator_result != LOAD_OK) {
-    NaClLog(1, "NaClTextSysDyncodeModify: "
-               "Validation of dynamic code failed\n");
+    NaClLog(1, "NaClSysDyncodeModify: Validation of dynamic code failed\n");
     retval = -NACL_ABI_EINVAL;
     goto cleanup_unlock;
   }
 
   if (!NaClTextMapWrapper(nap, dest, size, &mapped_addr)) {
     retval = -NACL_ABI_ENOMEM;
     goto cleanup_unlock;
   }
 
   if (LOAD_OK != NaClCopyCode(nap, dest, mapped_addr, code_copy, size)) {
-    NaClLog(1, "NaClTextSysDyncodeModify "
-               "Copying of replacement code failed\n");
+    NaClLog(1, "NaClSysDyncodeModify: Copying of replacement code failed\n");
     retval = -NACL_ABI_EINVAL;
     goto cleanup_unlock;
   }
   retval = 0;
 
   NaClTextMapClearCacheIfNeeded(nap, dest, size);
 
  cleanup_unlock:
   NaClXMutexUnlock(&nap->dynamic_load_mutex);
 
   if (code_copy != code_copy_buf) {
     free(code_copy);
   }
 
   return retval;
 }
 
-int32_t NaClTextSysDyncodeDelete(struct NaClAppThread *natp,
-                                 uint32_t             dest,
-                                 uint32_t             size) {
+int32_t NaClSysDyncodeDelete(struct NaClAppThread *natp,
+                             uint32_t             dest,
+                             uint32_t             size) {
   struct NaClApp              *nap = natp->nap;
   uintptr_t                    dest_addr;
   uint8_t                     *mapped_addr;
   int32_t                     retval = -NACL_ABI_EINVAL;
   struct NaClDynamicRegion    *region;
 
   if (NULL == nap->text_shm) {
-    NaClLog(1, "NaClTextSysDyncodeDelete: Dynamic loading not enabled\n");
+    NaClLog(1, "NaClSysDyncodeDelete: Dynamic loading not enabled\n");
     return -NACL_ABI_EINVAL;
   }
 
   if (0 == size) {
     /* Nothing to delete.  Just update our generation. */
     int gen;
     /* fetch current generation */
     NaClXMutexLock(&nap->dynamic_load_mutex);
     gen = nap->dynamic_delete_generation;
     NaClXMutexUnlock(&nap->dynamic_load_mutex);
     /* set our generation */
     NaClSetThreadGeneration(natp, gen);
     return 0;
   }
 
   dest_addr = NaClUserToSysAddrRange(nap, dest, size);
   if (kNaClBadAddress == dest_addr) {
-    NaClLog(1, "NaClTextSysDyncodeDelete: Address out of range\n");
+    NaClLog(1, "NaClSysDyncodeDelete: Address out of range\n");
     return -NACL_ABI_EFAULT;
   }
 
   NaClXMutexLock(&nap->dynamic_load_mutex);
 
   /*
    * this check ensures the to-be-deleted region is identical to a
    * previously inserted region, so no need to check for alignment/bounds/etc
    */
   region = NaClDynamicRegionFind(nap, dest_addr, size);
   if (NULL == region || region->start != dest_addr || region->size != size) {
-    NaClLog(1, "NaClTextSysDyncodeDelete: Can't find region to delete\n");
+    NaClLog(1, "NaClSysDyncodeDelete: Can't find region to delete\n");
     retval = -NACL_ABI_EFAULT;
     goto cleanup_unlock;
   }
 
 
   if (region->delete_generation < 0) {
     /* first deletion request */
 
     if (nap->dynamic_delete_generation == INT32_MAX) {
-      NaClLog(1, "NaClTextSysDyncodeDelete:"
+      NaClLog(1, "NaClSysDyncodeDelete:"
                  "Overflow, can only delete INT32_MAX regions\n");
       retval = -NACL_ABI_EFAULT;
       goto cleanup_unlock;
     }
 
     if (!NaClTextMapWrapper(nap, dest, size, &mapped_addr)) {
       retval = -NACL_ABI_ENOMEM;
       goto cleanup_unlock;
     }
 
@@ skipping 31 matching lines @@
     /*
      * Still waiting for some threads to report in...
      */
     retval = -NACL_ABI_EAGAIN;
   }
 
  cleanup_unlock:
   NaClXMutexUnlock(&nap->dynamic_load_mutex);
   return retval;
 }