Add missing locking around loaders list

runtime/bin/loader.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 
 #include "bin/loader.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/extensions.h"
@@ skipping 450 matching lines @@
 Loader::LoaderInfo* Loader::loader_infos_ = NULL;
 intptr_t Loader::loader_infos_length_ = 0;
 intptr_t Loader::loader_infos_capacity_ = 0;
 
 
 // Add a mapping from |port| to |isolate_data| (really the loader). When a
 // native message arrives, we use this map to report the I/O result to the
 // correct loader.
 // This happens whenever an isolate begins loading.
 void Loader::AddLoader(Dart_Port port, IsolateData* isolate_data) {
-  ASSERT(LoaderFor(port) == NULL);
+  MutexLocker ml(&loader_infos_lock_);
+  ASSERT(LoaderForLocked(port) == NULL);
   if (loader_infos_length_ == loader_infos_capacity_) {
     // Grow to an initial capacity or double in size.
     loader_infos_capacity_ =
         (loader_infos_capacity_ == 0) ? 4 : loader_infos_capacity_ * 2;
     loader_infos_ =
         reinterpret_cast<Loader::LoaderInfo*>(
             realloc(loader_infos_,
                     sizeof(Loader::LoaderInfo) * loader_infos_capacity_));
     ASSERT(loader_infos_ != NULL);
     // Initialize new entries.
     for (intptr_t i = loader_infos_length_; i < loader_infos_capacity_; i++) {
       loader_infos_[i].port = ILLEGAL_PORT;
       loader_infos_[i].isolate_data = NULL;
     }
   }
   ASSERT(loader_infos_length_ < loader_infos_capacity_);
   loader_infos_[loader_infos_length_].port = port;
   loader_infos_[loader_infos_length_].isolate_data = isolate_data;
   loader_infos_length_++;
-  ASSERT(LoaderFor(port) != NULL);
+  ASSERT(LoaderForLocked(port) != NULL);
 }
 
 
 // Remove |port| from the map.
 // This happens once an isolate has finished loading.
 void Loader::RemoveLoader(Dart_Port port) {
+  MutexLocker ml(&loader_infos_lock_);
   const intptr_t index = LoaderIndexFor(port);
   ASSERT(index >= 0);
   const intptr_t last = loader_infos_length_ - 1;
   ASSERT(last >= 0);
   if (index != last) {
     // Swap with the tail.
     loader_infos_[index] = loader_infos_[last];
   }
   loader_infos_length_--;
 }
 
 
 intptr_t Loader::LoaderIndexFor(Dart_Port port) {
   for (intptr_t i = 0; i < loader_infos_length_; i++) {
     if (loader_infos_[i].port == port) {
       return i;
     }
   }
   return -1;
 }
 
 
-Loader* Loader::LoaderFor(Dart_Port port) {
+Loader* Loader::LoaderForLocked(Dart_Port port) {

[zra, 2016/06/07 04:51:46]

ASSERT(loader_infos_lock_.IsOwnedByCurrentThread());

[Cutch, 2016/06/07 14:22:15]

The threads interface under bin/ does not have IsOwnedByCurrentThread.

   intptr_t index = LoaderIndexFor(port);
   if (index < 0) {
     return NULL;
   }
   return loader_infos_[index].isolate_data->loader();
 }
 
 
+Loader* Loader::LoaderFor(Dart_Port port) {
+  MutexLocker ml(&loader_infos_lock_);
+  return LoaderForLocked(port);
+}
+
+
 void Loader::NativeMessageHandler(Dart_Port dest_port_id,
                                   Dart_CObject* message) {
-  Loader* loader = LoaderFor(dest_port_id);
+  MutexLocker ml(&loader_infos_lock_);
+  Loader* loader = LoaderForLocked(dest_port_id);
   if (loader == NULL) {
     return;
   }
   loader->QueueMessage(message);
 }
 
 }  // namespace bin
 }  // namespace dart