PNaCl Dynamic Linking: Using unordered_set to disallow duplicate modules.

src/untrusted/pll_loader/pll_loader.cc

 // Copyright 2016 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/untrusted/pll_loader/pll_loader.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 
 #include "native_client/src/shared/platform/nacl_log.h"
 #include "native_client/src/untrusted/pnacl_dynloader/dynloader.h"
 
 namespace {
 
 // This is a simple implementation that does not support multiple threads.
 // It demonstrates how we can optimize if we know that pthread_create()
 // will never be called.
 void *TLSBlockGetter(PLLTLSBlockGetter *closure) {
   return closure->arg;
 }
 
+// Given a pathname, return the filename it points to (or NULL if the path
+// ends with '/').
+const char *GetSoname(const char *path) {

[Mark Seaborn, 2016/03/25 17:57:28]

I'm not sure it makes sense to add this because we don't really want the PLL
loader to be parsing filenames, only constructing them (i.e. building "directory
+ soname" when searching).

How about instead:

* Leave the behaviour of AddByFilename() as it is.

* Add a couple of new methods:

const PLLRoot *AddBySoname(const char *soname);
void SetSonameSearchPath(const std::vector<std::string> &dir_list);

* Change pll_loader_test to exercise those new methods (in addition to
AddByFilename()) and to test that AddBySoname() de-dups.

[Sean Klein, 2016/03/25 18:43:57]

Yeah, it felt like a temporary solution anyway (I was never under the impression
"GetSoname" would stick around once we got directory searching working).

I'll update to the new version. If possible, I might try to hide "AddByFilename"
from the API, and instead use directory/soname setting functions instead.

+  const char *base = path;
+  while (*path) {
+    if (*path == '/')
+      base = path + 1;
+    path++;
+  }
+  return base;
+}
+
 }  // namespace
 
 uint32_t PLLModule::HashString(const char *sp) {
   uint32_t h = 5381;
   for (unsigned char c = *sp; c != '\0'; c = *++sp)
     h = h * 33 + c;
   return h;
 }
 
 bool PLLModule::IsMaybeExported(uint32_t hash1) {
@@ skipping 44 matching lines @@
     NaClLog(LOG_FATAL, "InstantiateTLSBlock: Allocation failed\n");
   }
   memcpy(base, root_->tls_template, root_->tls_template_data_size);
   size_t bss_size = (root_->tls_template_total_size -
                      root_->tls_template_data_size);
   memset((char *) base + root_->tls_template_data_size, 0, bss_size);
   return base;
 }
 
 void ModuleSet::AddByFilename(const char *filename) {
+  std::string soname(GetSoname(filename));
+  if (soname.empty()) {
+    NaClLog(LOG_FATAL, "Invalid PLL Path: %s\n", filename);
+  }
+  if (sonames_.count(soname) != 0) {
+    NaClLog(LOG_FATAL, "PLL Loader found duplicate PLL: %s\n", filename);
+  }
+  sonames_.insert(soname);
+
   void *pso_root;
   int err = pnacl_load_elf_file(filename, &pso_root);
   if (err != 0) {
     NaClLog(LOG_FATAL, "pnacl_load_elf_file() failed: errno=%d\n", err);
   }
   modules_.push_back(PLLModule((const PLLRoot *) pso_root));
 }
 
 void *ModuleSet::GetSym(const char *name) {
   for (auto &module : modules_) {
@@ skipping 15 matching lines @@
       *(uintptr_t *) module.root()->imported_ptrs[index] += sym_value;
     }
 
     // Initialize TLS.
     if (PLLTLSBlockGetter *tls_block_getter = module.root()->tls_block_getter) {
       tls_block_getter->func = TLSBlockGetter;
       tls_block_getter->arg = module.InstantiateTLSBlock();
     }
   }
 }