Close and delete pnacl temp files when compile or link fails.

ppapi/native_client/src/trusted/plugin/pnacl_coordinator.cc

 // Copyright (c) 2012 The Chromium 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/trusted/plugin/pnacl_coordinator.h"
 
 #include <utility>
 #include <vector>
 
 #include "native_client/src/include/portability_io.h"
@@ skipping 97 matching lines @@
   SNPRINTF(reinterpret_cast<char *>(identifier_), sizeof identifier_,
            "%"NACL_PRIu32, next_identifier);
 }
 
 LocalTempFile::~LocalTempFile() {
   PLUGIN_PRINTF(("LocalTempFile::~LocalTempFile\n"));
   NaClDescUnref(reinterpret_cast<NaClDesc*>(rng_desc_));
 }
 
 void LocalTempFile::OpenWrite(const pp::CompletionCallback& cb) {
-  PLUGIN_PRINTF(("LocalTempFile::OpenWrite\n"));
   done_callback_ = cb;
   // If we don't already have a filename, generate one.
   if (filename_ == "") {
     // Get a random temp file name.
     filename_ =
         nacl::string(kPnaclTempDir) + "/" + Random32CharHexString(rng_desc_);
     // Remember the ref used to open for writing and reading.
     file_ref_.reset(new pp::FileRef(*file_system_, filename_.c_str()));
   }
+  PLUGIN_PRINTF(("LocalTempFile::OpenWrite: %s\n", filename_.c_str()));
   // Open the writeable file.
   write_io_.reset(new pp::FileIO(plugin_));
   pp::CompletionCallback open_write_cb =
       callback_factory_.NewCallback(&LocalTempFile::WriteFileDidOpen);
   write_io_->Open(*file_ref_,
                   PP_FILEOPENFLAG_WRITE |
                   PP_FILEOPENFLAG_CREATE |
                   PP_FILEOPENFLAG_EXCLUSIVE,
                   open_write_cb);
 }
@@ skipping 49 matching lines @@
     core->CallOnMainThread(0, done_callback_, pp_error);
     return;
   }
   // The descriptor for a writeable file needs to have quota management.
   write_wrapper_.reset(
       plugin_->wrapper_factory()->MakeFileDescQuota(fd, O_RDWR, identifier_));
   core->CallOnMainThread(0, done_callback_, PP_OK);
 }
 
 void LocalTempFile::OpenRead(const pp::CompletionCallback& cb) {
-  PLUGIN_PRINTF(("LocalTempFile::OpenRead\n"));
+  PLUGIN_PRINTF(("LocalTempFile::OpenRead: %s\n", filename_.c_str()));
   done_callback_ = cb;
   // Open the read only file.
   read_io_.reset(new pp::FileIO(plugin_));
   pp::CompletionCallback open_read_cb =
       callback_factory_.NewCallback(&LocalTempFile::ReadFileDidOpen);
   read_io_->Open(*file_ref_, PP_FILEOPENFLAG_READ, open_read_cb);
 }
 
 void LocalTempFile::ReadFileDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("LocalTempFile::ReadFileDidOpen (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   // Run the client's completion callback.
   pp::Core* core = pp::Module::Get()->core();
   if (pp_error != PP_OK) {
     core->CallOnMainThread(0, done_callback_, pp_error);
     return;
   }
   // Remember the object temporary file descriptor.
   int32_t fd = GetFD(pp_error, *read_io_, kReadOnly);
   if (fd < 0) {
     core->CallOnMainThread(0, done_callback_, PP_ERROR_FAILED);
     return;
   }
   read_wrapper_.reset(plugin_->wrapper_factory()->MakeFileDesc(fd, O_RDONLY));
   core->CallOnMainThread(0, done_callback_, PP_OK);
 }
 
 void LocalTempFile::Close(const pp::CompletionCallback& cb) {
-  PLUGIN_PRINTF(("LocalTempFile::Close\n"));
+  PLUGIN_PRINTF(("LocalTempFile::Close: %s\n", filename_.c_str()));
   // Close the open DescWrappers and FileIOs.
   if (write_io_.get() != NULL) {
     write_io_->Close();
   }
   write_wrapper_.reset(NULL);
   write_io_.reset(NULL);
   if (read_io_.get() != NULL) {
     read_io_->Close();
   }
   read_wrapper_.reset(NULL);
   read_io_.reset(NULL);
   // Run the client's completion callback.
   pp::Core* core = pp::Module::Get()->core();
   core->CallOnMainThread(0, cb, PP_OK);
 }
 
 void LocalTempFile::Delete(const pp::CompletionCallback& cb) {
-  PLUGIN_PRINTF(("LocalTempFile::Delete\n"));
+  PLUGIN_PRINTF(("LocalTempFile::Delete: %s\n", filename_.c_str()));
   file_ref_->Delete(cb);
 }
 
 void LocalTempFile::Rename(const nacl::string& new_name,
                            const pp::CompletionCallback& cb) {
   // Rename the temporary file.
   filename_ = nacl::string(kPnaclTempDir) + "/" + new_name;
-  PLUGIN_PRINTF(("LocalTempFile::Rename to %s\n", filename_.c_str()));
+  PLUGIN_PRINTF(("LocalTempFile::Rename %s to %s\n",
+                 file_ref_->GetName().AsString().c_str(),
+                 filename_.c_str()));
   // Remember the old ref until the rename is complete.
   old_ref_.reset(file_ref_.release());
   file_ref_.reset(new pp::FileRef(*file_system_, filename_.c_str()));
   old_ref_->Rename(*file_ref_, cb);
 }
 
 void LocalTempFile::FinishRename() {
   // Now we can release the old ref.
   old_ref_.reset(NULL);
 }
@@ skipping 167 matching lines @@
   // ResourcesDidLoad will be invoked when all resources have been received.
   return coordinator;
 }
 
 int32_t PnaclCoordinator::GetLoadedFileDesc(int32_t pp_error,
                                             const nacl::string& url,
                                             const nacl::string& component) {
   PLUGIN_PRINTF(("PnaclCoordinator::GetLoadedFileDesc (pp_error=%"
                  NACL_PRId32", url=%s, component=%s)\n", pp_error,
                  url.c_str(), component.c_str()));
-  PLUGIN_PRINTF(("PnaclCoordinator::GetLoadedFileDesc (pp_error=%d\n"));
   ErrorInfo error_info;
-  int32_t file_desc = plugin_->GetPOSIXFileDesc(url);
-  if (pp_error != PP_OK || file_desc == NACL_NO_FILE_DESC) {
+  int32_t file_desc_ok_to_close = plugin_->GetPOSIXFileDesc(url);
+  if (pp_error != PP_OK || file_desc_ok_to_close == NACL_NO_FILE_DESC) {
     if (pp_error == PP_ERROR_ABORTED) {
       plugin_->ReportLoadAbort();
     } else {
       ReportPpapiError(pp_error, component + " load failed.");
     }
-    return -1;
-  }
-  int32_t file_desc_ok_to_close = DUP(file_desc);

[jvoung - send to chromium..., 2012/02/29 23:18:49]

removed this part because it looked like GetLoadedFileDesc() already does a DUP.

-  if (file_desc_ok_to_close == NACL_NO_FILE_DESC) {
-    ReportPpapiError(PP_ERROR_FAILED, component + " could not dup fd.");
-    return -1;
+    return NACL_NO_FILE_DESC;
   }
   return file_desc_ok_to_close;
 }
 
 PnaclCoordinator::PnaclCoordinator(
     Plugin* plugin,
     const nacl::string& pexe_url,
     const nacl::string& cache_identity,
     const pp::CompletionCallback& translate_notify_callback)
   : plugin_(plugin),
@@ skipping 33 matching lines @@
 
 void PnaclCoordinator::ReportPpapiError(int32_t pp_error,
                                         const nacl::string& message) {
   error_info_.SetReport(ERROR_UNKNOWN,
                         nacl::string("PnaclCoordinator: ") + message);
   ReportPpapiError(pp_error);
 }
 
 void PnaclCoordinator::ReportPpapiError(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::ReportPpappiError (pp_error=%"
-                 NACL_PRId32", error_code=%d, message=%s)\n",
+                 NACL_PRId32", error_code=%d, message='%s')\n",
                  pp_error, error_info_.error_code(),
                  error_info_.message().c_str()));
   plugin_->ReportLoadError(error_info_);
   // Free all the intermediate callbacks we ever created.
   // Note: this doesn't *cancel* the callbacks from the factories attached
   // to the various helper classes (e.g., pnacl_resources). Thus, those
   // callbacks may still run asynchronously.  We let those run but ignore
   // any other errors they may generate so that they do not end up running
   // translate_notify_callback_, which has already been freed.
   callback_factory_.CancelAll();
   if (!error_already_reported_) {
     error_already_reported_ = true;
     translate_notify_callback_.Run(pp_error);
   } else {
     PLUGIN_PRINTF(("PnaclCoordinator::ReportPpapiError an earlier error was "
                    "already reported -- Skipping.\n"));
   }
 }
 
 void PnaclCoordinator::TranslateFinished(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::TranslateFinished (pp_error=%"
                  NACL_PRId32")\n", pp_error));
-  if (pp_error != PP_OK) {
-    ReportPpapiError(pp_error);
-    // TODO(sehr): Delete the object and nexe temporary files.
-    return;
-  }
-  // Close the object temporary file.
+  // Save the translate error code, and inspect after cleaning up junk files.
+  // Note: If there was a surfaway and the file objects were actually
+  // destroyed, the we are in trouble since the obj_file_, nexe_file_,
+  // etc. may have been destroyed.
+  translate_finish_error_ = pp_error;
+
+  // Close the object temporary file (regardless of error code).
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::ObjectFileWasClosed);
   obj_file_->Close(cb);
 }
 
 void PnaclCoordinator::ObjectFileWasClosed(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::ObjectFileWasClosed (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_OK) {
     ReportPpapiError(pp_error);
@@ skipping 18 matching lines @@
   nexe_file_->Close(cb);
 }
 
 void PnaclCoordinator::NexeFileWasClosed(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::NexeFileWasClosed (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_OK) {
     ReportPpapiError(pp_error);
     return;
   }
+  // Now that cleanup of the obj file is done, check the old TranslateFinished
+  // error code to see if we should proceed normally or not.
+  if (translate_finish_error_ != PP_OK) {
+    pp::CompletionCallback cb =
+        callback_factory_.NewCallback(&PnaclCoordinator::NexeFileWasDeleted);
+    nexe_file_->Delete(cb);
+    return;
+  }
+
   // Rename the nexe file to the cache id.
   if (cache_identity_ != "") {
     pp::CompletionCallback cb =
          callback_factory_.NewCallback(&PnaclCoordinator::NexeFileWasRenamed);
     nexe_file_->Rename(cache_identity_, cb);
   } else {
     // For now tolerate bitcode that is missing a cache identity.
     PLUGIN_PRINTF(("PnaclCoordinator -- WARNING: missing cache identity,"
                    " not caching.\n"));
     NexeFileWasRenamed(PP_OK);
@@ skipping 22 matching lines @@
   if (pp_error != PP_OK) {
     ReportPpapiError(pp_error, "Failed to open translated nexe.");
     return;
   }
   // Transfer ownership of the nexe wrapper to the coordinator.
   translated_fd_.reset(nexe_file_->release_read_wrapper());
   plugin_->EnqueueProgressEvent(Plugin::kProgressEventProgress);
   translate_notify_callback_.Run(pp_error);
 }
 
+void PnaclCoordinator::NexeFileWasDeleted(int32_t pp_error) {
+  PLUGIN_PRINTF(("PnaclCoordinator::NexeFileWasDeleted (pp_error=%"
+                 NACL_PRId32")\n", pp_error));
+  ReportPpapiError(translate_finish_error_);
+}
+
 void PnaclCoordinator::TranslateFailed(const nacl::string& error_string) {
-  PLUGIN_PRINTF(("PnaclCoordinator::TranslateFailed (error_string=%"
-                 NACL_PRId32")\n", error_string.c_str()));
+  PLUGIN_PRINTF(("PnaclCoordinator::TranslateFailed (error_string='%s')\n",
+                 error_string.c_str()));
   pp::Core* core = pp::Module::Get()->core();
   error_info_.SetReport(ERROR_UNKNOWN,
                         nacl::string("PnaclCoordinator: ") + error_string);
   core->CallOnMainThread(0, report_translate_finished_, PP_ERROR_FAILED);
 }
 
 void PnaclCoordinator::ResourcesDidLoad(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::ResourcesDidLoad (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_OK) {
@@ skipping 38 matching lines @@
     pp::CompletionCallback cb =
         callback_factory_.NewCallback(&PnaclCoordinator::CachedFileDidOpen);
     nexe_file_->OpenRead(cb);
   } else {
     // For now, tolerate lack of cache identity...
     CachedFileDidOpen(PP_ERROR_FAILED);
   }
 }
 
 void PnaclCoordinator::CachedFileDidOpen(int32_t pp_error) {
-
+  PLUGIN_PRINTF(("PnaclCoordinator::CachedFileDidOpen (pp_error=%"
+                 NACL_PRId32")\n", pp_error));
   if (pp_error == PP_OK) {
     NexeReadDidOpen(PP_OK);
     return;
   }
+  // Otherwise, load the pexe and set up temp files for translation.
+  PLUGIN_PRINTF(("PnaclCoordinator::Doing BC StreamAsFile (url='%s')\n",
+                 pexe_url_.c_str()));
+  pp::CompletionCallback cb =
+      callback_factory_.NewCallback(&PnaclCoordinator::BitcodeFileDidOpen);
+  if (!plugin_->StreamAsFile(pexe_url_, cb.pp_completion_callback())) {
+    ReportNonPpapiError(nacl::string("failed to download ") + pexe_url_ + ".");
+  }
+}
+
+void PnaclCoordinator::BitcodeFileDidOpen(int32_t pp_error) {
+  PLUGIN_PRINTF(("PnaclCoordinator::BitcodeFileDidOpen (pp_error=%"
+                 NACL_PRId32")\n", pp_error));
+  // We have to get the fd immediately after streaming.
+  int32_t fd = GetLoadedFileDesc(pp_error, pexe_url_, "pexe");
+  if (fd < 0) {
+    // Error already reported by GetLoadedFileDesc().
+    return;
+  }
+  pexe_wrapper_.reset(plugin_->wrapper_factory()->MakeFileDesc(fd, O_RDONLY));
 
   obj_file_.reset(new LocalTempFile(plugin_, file_system_.get()));
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::ObjectWriteDidOpen);
   obj_file_->OpenWrite(cb);
 }
 
 void PnaclCoordinator::ObjectWriteDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::ObjectWriteDidOpen (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_OK) {
     ReportPpapiError(pp_error);
     return;
   }
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(&PnaclCoordinator::ObjectReadDidOpen);
   obj_file_->OpenRead(cb);
 }
 
 void PnaclCoordinator::ObjectReadDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::ObjectReadDidOpen (pp_error=%"
                  NACL_PRId32")\n", pp_error));
   if (pp_error != PP_OK) {
     ReportPpapiError(pp_error);
     return;
   }
   // Create the nexe file for connecting ld and sel_ldr.
+  // Start translation when done this last step of setup!
   nexe_file_.reset(new LocalTempFile(plugin_, file_system_.get()));
   pp::CompletionCallback cb =
-      callback_factory_.NewCallback(&PnaclCoordinator::NexeWriteDidOpen);
+      callback_factory_.NewCallback(&PnaclCoordinator::RunTranslate);
   nexe_file_->OpenWrite(cb);
 }
 
-void PnaclCoordinator::NexeWriteDidOpen(int32_t pp_error) {
-  PLUGIN_PRINTF(("PnaclCoordinator::NexeWriteDidOpen (pp_error=%"
-                 NACL_PRId32")\n", pp_error));
-  if (pp_error != PP_OK) {
-    ReportPpapiError(pp_error);
-    return;
-  }
-  // Load the pexe file and get the translation started.
-  pp::CompletionCallback cb =
-      callback_factory_.NewCallback(&PnaclCoordinator::RunTranslate);
-
-  if (!plugin_->StreamAsFile(pexe_url_, cb.pp_completion_callback())) {
-    ReportNonPpapiError(nacl::string("failed to download ") + pexe_url_ + ".");
-  }
-}
-
 void PnaclCoordinator::RunTranslate(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::RunTranslate (pp_error=%"
                  NACL_PRId32")\n", pp_error));
-  int32_t fd = GetLoadedFileDesc(pp_error, pexe_url_, "pexe");
-  if (fd < 0) {
-    return;
-  }
-  pexe_wrapper_.reset(plugin_->wrapper_factory()->MakeFileDesc(fd, O_RDONLY));
   // Invoke llc followed by ld off the main thread.  This allows use of
   // blocking RPCs that would otherwise block the JavaScript main thread.
   report_translate_finished_ =
       callback_factory_.NewCallback(&PnaclCoordinator::TranslateFinished);
   translate_thread_.reset(new NaClThread);
   if (translate_thread_ == NULL) {
     ReportNonPpapiError("could not allocate thread struct.");
     return;
   }
   const int32_t kArbitraryStackSize = 128 * 1024;
@@ skipping 100 matching lines @@
   nacl::MutexLocker ml(&subprocess_mu_);
   return subprocesses_should_die_;
 }
 
 void PnaclCoordinator::SetSubprocessesShouldDie(bool subprocesses_should_die) {
   nacl::MutexLocker ml(&subprocess_mu_);
   subprocesses_should_die_ = subprocesses_should_die;
 }
 
 }  // namespace plugin