Provide metadata to validator to allow faster caching.

src/trusted/service_runtime/sel_validate_image.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 "native_client/src/include/concurrency_ops.h"
 #include "native_client/src/shared/platform/nacl_log.h"
 #include "native_client/src/shared/utils/types.h"
 #include "native_client/src/trusted/service_runtime/sel_ldr.h"
@@ skipping 12 matching lines @@
     case NaClValidationFailed:
     case NaClValidationFailedNotImplemented:
     case NaClValidationFailedCpuNotSupported:
     case NaClValidationFailedSegmentationIssue:
     default:
       return LOAD_VALIDATION_FAILED;
   }
 }
 
 int NaClValidateCode(struct NaClApp *nap, uintptr_t guest_addr,
-                     uint8_t *data, size_t size) {
+                     uint8_t *data, size_t size,
+                     const struct NaClValidationMetadata *metadata) {
   NaClValidationStatus status = NaClValidationSucceeded;
   struct NaClValidationCache *cache = nap->validation_cache;
   const struct NaClValidatorInterface *validator = nap->validator;
 
   if (size < kMinimumCachedCodeSize) {
     /*
      * Don't cache the validation of small code chunks for three reasons:
      * 1) The size of the validation cache will be bounded.  Cache entries are
      *    better used for bigger code.
      * 2) The per-transaction overhead of validation caching is more noticeable
      *    for small code.
      * 3) JITs tend to generate a lot of small code chunks, and JITed code may
      *    never be seen again.  Currently code size is the best mechanism we
      *    have for heuristically distinguishing between JIT and static code.
      *    (In practice most Mono JIT blocks are less than 1k, and a quick look
      *    didn't show any above 35k.)
      * The choice of what constitutes "small" is arbitrary, and should be
      * empirically tuned.
      * TODO(ncbray) let the syscall specify if the code is cached or not.
      */
+    metadata = NULL;
     cache = NULL;
   }
 
   /* As fixed feature mode implies the text should be readonly, and
    * stubout mode implies updating the text, disallow their use together.
    */
   if (nap->validator_stub_out_mode && nap->fixed_feature_cpu_mode) {
     NaClLog(LOG_FATAL,
             "stub_out_mode and fixed_feature_cpu_mode are incompatible\n");
     return LOAD_VALIDATION_FAILED;
   }
   if (nap->validator_stub_out_mode) {
     /* Validation caching is currently incompatible with stubout. */
+    metadata = NULL;
     cache = NULL;
     /* In stub out mode, we do two passes.  The second pass acts as a
        sanity check that bad instructions were indeed overwritten with
        allowable HLTs. */
     status = validator->Validate(guest_addr, data, size,
                                  TRUE, /* stub out */
                                  FALSE, /* text is not read-only */
                                  nap->cpu_features,
+                                 metadata,
                                  cache);
   }
   if (status == NaClValidationSucceeded) {
     /* Fixed feature CPU mode implies read-only. */
     int readonly_text = nap->fixed_feature_cpu_mode;
     status = validator->Validate(guest_addr, data, size,
                                  FALSE, /* do not stub out */
                                  readonly_text,
                                  nap->cpu_features,
+                                 metadata,
                                  cache);
   }
   return NaClValidateStatus(status);
 }
 
 int NaClValidateCodeReplacement(struct NaClApp *nap, uintptr_t guest_addr,
                                 uint8_t *data_old, uint8_t *data_new,
                                 size_t size) {
   if (nap->validator_stub_out_mode) return LOAD_BAD_FILE;
   if (nap->fixed_feature_cpu_mode) return LOAD_BAD_FILE;
@@ skipping 46 matching lines @@
   endp = nap->mem_start + nap->static_text_end;
   regionsize = endp - memp;
   if (endp < memp) {
     return LOAD_NO_MEMORY;
   }
 
   if (nap->skip_validator) {
     NaClLog(LOG_ERROR, "VALIDATION SKIPPED.\n");
     return LOAD_OK;
   } else {
+    /* TODO(ncbray) metadata for the main image. */
     rcode = NaClValidateCode(nap, NACL_TRAMPOLINE_END,
-                             (uint8_t *) memp, regionsize);
+                             (uint8_t *) memp, regionsize, NULL);
     if (LOAD_OK != rcode) {
       if (nap->ignore_validator_result) {
         NaClLog(LOG_ERROR, "VALIDATION FAILED: continuing anyway...\n");
         rcode = LOAD_OK;
       } else {
         NaClLog(LOG_ERROR, "VALIDATION FAILED.\n");
         NaClLog(LOG_ERROR,
                 "Run sel_ldr in debug mode to ignore validation failure.\n");
         NaClLog(LOG_ERROR,
                 "Run ncval <module-name> for validation error details.\n");
         rcode = LOAD_VALIDATION_FAILED;
       }
     }
   }
   return rcode;
 }