service_runtime.cc revision c2db58bd994c04d98e4ee2cd7565b71548655fe3 
1/*
2 * Copyright (c) 2012 The Chromium Authors. All rights reserved.
3 * Use of this source code is governed by a BSD-style license that can be
4 * found in the LICENSE file.
5 */
6
7#define NACL_LOG_MODULE_NAME "Plugin::ServiceRuntime"
8
9#include "ppapi/native_client/src/trusted/plugin/service_runtime.h"
10
11#include <string.h>
12#include <set>
13#include <string>
14#include <utility>
15
16#include "base/compiler_specific.h"
17
18#include "native_client/src/include/checked_cast.h"
19#include "native_client/src/include/portability_io.h"
20#include "native_client/src/include/portability_string.h"
21#include "native_client/src/include/nacl_macros.h"
22#include "native_client/src/include/nacl_scoped_ptr.h"
23#include "native_client/src/include/nacl_string.h"
24#include "native_client/src/shared/platform/nacl_check.h"
25#include "native_client/src/shared/platform/nacl_log.h"
26#include "native_client/src/shared/platform/nacl_sync.h"
27#include "native_client/src/shared/platform/nacl_sync_checked.h"
28#include "native_client/src/shared/platform/nacl_sync_raii.h"
29#include "native_client/src/shared/platform/scoped_ptr_refcount.h"
30#include "native_client/src/trusted/desc/nacl_desc_imc.h"
31// remove when we no longer need to cast the DescWrapper below.
32#include "native_client/src/trusted/desc/nacl_desc_io.h"
33#include "native_client/src/trusted/desc/nrd_xfer.h"
34#include "native_client/src/trusted/nonnacl_util/sel_ldr_launcher.h"
35
36// This is here due to a Windows API collision; plugin.h through
37// file_downloader.h transitively includes Instance.h which defines a
38// PostMessage method, so this undef must appear before any of those.
39#ifdef PostMessage
40#undef PostMessage
41#endif
42#include "native_client/src/public/imc_types.h"
43#include "native_client/src/trusted/service_runtime/nacl_error_code.h"
44#include "native_client/src/trusted/validator/nacl_file_info.h"
45
46#include "ppapi/c/pp_errors.h"
47#include "ppapi/c/trusted/ppb_file_io_trusted.h"
48#include "ppapi/cpp/core.h"
49#include "ppapi/cpp/completion_callback.h"
50#include "ppapi/cpp/file_io.h"
51
52#include "ppapi/native_client/src/trusted/plugin/manifest.h"
53#include "ppapi/native_client/src/trusted/plugin/plugin.h"
54#include "ppapi/native_client/src/trusted/plugin/plugin_error.h"
55#include "ppapi/native_client/src/trusted/plugin/pnacl_coordinator.h"
56#include "ppapi/native_client/src/trusted/plugin/pnacl_resources.h"
57#include "ppapi/native_client/src/trusted/plugin/sel_ldr_launcher_chrome.h"
58#include "ppapi/native_client/src/trusted/plugin/srpc_client.h"
59#include "ppapi/native_client/src/trusted/weak_ref/call_on_main_thread.h"
60
61namespace {
62
63// For doing crude quota enforcement on writes to temp files.
64// We do not allow a temp file bigger than 512 MB for now.
65const uint64_t kMaxTempQuota = 0x20000000;
66
67}  // namespace
68
69namespace plugin {
70
71PluginReverseInterface::PluginReverseInterface(
72    nacl::WeakRefAnchor* anchor,
73    Plugin* plugin,
74    const Manifest* manifest,
75    ServiceRuntime* service_runtime,
76    pp::CompletionCallback init_done_cb,
77    pp::CompletionCallback crash_cb)
78      : anchor_(anchor),
79        plugin_(plugin),
80        manifest_(manifest),
81        service_runtime_(service_runtime),
82        shutting_down_(false),
83        init_done_cb_(init_done_cb),
84        crash_cb_(crash_cb) {
85  NaClXMutexCtor(&mu_);
86  NaClXCondVarCtor(&cv_);
87}
88
89PluginReverseInterface::~PluginReverseInterface() {
90  NaClCondVarDtor(&cv_);
91  NaClMutexDtor(&mu_);
92}
93
94void PluginReverseInterface::ShutDown() {
95  NaClLog(4, "PluginReverseInterface::Shutdown: entered\n");
96  nacl::MutexLocker take(&mu_);
97  shutting_down_ = true;
98  NaClXCondVarBroadcast(&cv_);
99  NaClLog(4, "PluginReverseInterface::Shutdown: broadcasted, exiting\n");
100}
101
102void PluginReverseInterface::Log(nacl::string message) {
103  LogToJavaScriptConsoleResource* continuation =
104      new LogToJavaScriptConsoleResource(message);
105  CHECK(continuation != NULL);
106  NaClLog(4, "PluginReverseInterface::Log(%s)\n", message.c_str());
107  plugin::WeakRefCallOnMainThread(
108      anchor_,
109      0,  /* delay in ms */
110      this,
111      &plugin::PluginReverseInterface::Log_MainThreadContinuation,
112      continuation);
113}
114
115void PluginReverseInterface::DoPostMessage(nacl::string message) {
116  PostMessageResource* continuation = new PostMessageResource(message);
117  CHECK(continuation != NULL);
118  NaClLog(4, "PluginReverseInterface::DoPostMessage(%s)\n", message.c_str());
119  plugin::WeakRefCallOnMainThread(
120      anchor_,
121      0,  /* delay in ms */
122      this,
123      &plugin::PluginReverseInterface::PostMessage_MainThreadContinuation,
124      continuation);
125}
126
127void PluginReverseInterface::StartupInitializationComplete() {
128  NaClLog(4, "PluginReverseInterface::StartupInitializationComplete\n");
129  if (init_done_cb_.pp_completion_callback().func != NULL) {
130    NaClLog(4,
131            "PluginReverseInterface::StartupInitializationComplete:"
132            " invoking CB\n");
133    pp::Module::Get()->core()->CallOnMainThread(0, init_done_cb_, PP_OK);
134  } else {
135    NaClLog(1,
136            "PluginReverseInterface::StartupInitializationComplete:"
137            " init_done_cb_ not valid, skipping.\n");
138  }
139}
140
141void PluginReverseInterface::Log_MainThreadContinuation(
142    LogToJavaScriptConsoleResource* p,
143    int32_t err) {
144  UNREFERENCED_PARAMETER(err);
145  NaClLog(4,
146          "PluginReverseInterface::Log_MainThreadContinuation(%s)\n",
147          p->message.c_str());
148  plugin_->AddToConsole(p->message);
149}
150void PluginReverseInterface::PostMessage_MainThreadContinuation(
151    PostMessageResource* p,
152    int32_t err) {
153  UNREFERENCED_PARAMETER(err);
154  NaClLog(4,
155          "PluginReverseInterface::PostMessage_MainThreadContinuation(%s)\n",
156          p->message.c_str());
157  plugin_->PostMessage(std::string("DEBUG_POSTMESSAGE:") + p->message);
158}
159
160bool PluginReverseInterface::EnumerateManifestKeys(
161    std::set<nacl::string>* out_keys) {
162  Manifest const* mp = manifest_;
163
164  if (!mp->GetFileKeys(out_keys)) {
165    return false;
166  }
167
168  return true;
169}
170
171// TODO(bsy): OpenManifestEntry should use the manifest to ResolveKey
172// and invoke StreamAsFile with a completion callback that invokes
173// GetPOSIXFileDesc.
174bool PluginReverseInterface::OpenManifestEntry(nacl::string url_key,
175                                               struct NaClFileInfo* info) {
176  ErrorInfo error_info;
177  bool op_complete = false;  // NB: mu_ and cv_ also controls access to this!
178  // The to_open object is owned by the weak ref callback. Because this function
179  // waits for the callback to finish, the to_open object will be deallocated on
180  // the main thread before this function can return. The pointers it contains
181  // to stack variables will not leak.
182  OpenManifestEntryResource* to_open =
183      new OpenManifestEntryResource(url_key, info,
184                                    &error_info, &op_complete);
185  CHECK(to_open != NULL);
186  NaClLog(4, "PluginReverseInterface::OpenManifestEntry: %s\n",
187          url_key.c_str());
188  // This assumes we are not on the main thread.  If false, we deadlock.
189  plugin::WeakRefCallOnMainThread(
190      anchor_,
191      0,
192      this,
193      &plugin::PluginReverseInterface::OpenManifestEntry_MainThreadContinuation,
194      to_open);
195  NaClLog(4,
196          "PluginReverseInterface::OpenManifestEntry:"
197          " waiting on main thread\n");
198  bool shutting_down;
199  do {
200    nacl::MutexLocker take(&mu_);
201    for (;;) {
202      NaClLog(4,
203              "PluginReverseInterface::OpenManifestEntry:"
204              " got lock, checking shutdown and completion: (%s, %s)\n",
205              shutting_down_ ? "yes" : "no",
206              op_complete ? "yes" : "no");
207      shutting_down = shutting_down_;
208      if (op_complete || shutting_down) {
209        NaClLog(4,
210                "PluginReverseInterface::OpenManifestEntry:"
211                " done!\n");
212        break;
213      }
214      NaClXCondVarWait(&cv_, &mu_);
215    }
216  } while (0);
217  if (shutting_down) {
218    NaClLog(4,
219            "PluginReverseInterface::OpenManifestEntry:"
220            " plugin is shutting down\n");
221    return false;
222  }
223  // out_desc has the returned descriptor if successful, else -1.
224
225  // The caller is responsible for not closing *out_desc.  If it is
226  // closed prematurely, then another open could re-use the OS
227  // descriptor, confusing the opened_ map.  If the caller is going to
228  // want to make a NaClDesc object and transfer it etc., then the
229  // caller should DUP the descriptor (but remember the original
230  // value) for use by the NaClDesc object, which closes when the
231  // object is destroyed.
232  NaClLog(4,
233          "PluginReverseInterface::OpenManifestEntry:"
234          " *out_desc = %d\n",
235          info->desc);
236  if (info->desc == -1) {
237    // TODO(bsy,ncbray): what else should we do with the error?  This
238    // is a runtime error that may simply be a programming error in
239    // the untrusted code, or it may be something else wrong w/ the
240    // manifest.
241    NaClLog(4,
242            "OpenManifestEntry: failed for key %s, code %d (%s)\n",
243            url_key.c_str(),
244            error_info.error_code(),
245            error_info.message().c_str());
246  }
247  return true;
248}
249
250// Transfer point from OpenManifestEntry() which runs on the main thread
251// (Some PPAPI actions -- like StreamAsFile -- can only run on the main thread).
252// OpenManifestEntry() is waiting on a condvar for this continuation to
253// complete.  We Broadcast and awaken OpenManifestEntry() whenever we are done
254// either here, or in a later MainThreadContinuation step, if there are
255// multiple steps.
256void PluginReverseInterface::OpenManifestEntry_MainThreadContinuation(
257    OpenManifestEntryResource* p,
258    int32_t err) {
259  OpenManifestEntryResource *open_cont;
260  UNREFERENCED_PARAMETER(err);
261  // CallOnMainThread continuations always called with err == PP_OK.
262
263  NaClLog(4, "Entered OpenManifestEntry_MainThreadContinuation\n");
264
265  std::string mapped_url;
266  PnaclOptions pnacl_options;
267  if (!manifest_->ResolveKey(p->url, &mapped_url,
268                             &pnacl_options, p->error_info)) {
269    NaClLog(4, "OpenManifestEntry_MainThreadContinuation: ResolveKey failed\n");
270    // Failed, and error_info has the details on what happened.  Wake
271    // up requesting thread -- we are done.
272    nacl::MutexLocker take(&mu_);
273    *p->op_complete_ptr = true;  // done...
274    p->file_info->desc = -1;  // but failed.
275    NaClXCondVarBroadcast(&cv_);
276    return;
277  }
278  NaClLog(4,
279          "OpenManifestEntry_MainThreadContinuation: "
280          "ResolveKey: %s -> %s (pnacl_translate(%d))\n",
281          p->url.c_str(), mapped_url.c_str(), pnacl_options.translate());
282
283  open_cont = new OpenManifestEntryResource(*p);  // copy ctor!
284  CHECK(open_cont != NULL);
285  open_cont->url = mapped_url;
286  if (!pnacl_options.translate()) {
287    pp::CompletionCallback stream_cc = WeakRefNewCallback(
288        anchor_,
289        this,
290        &PluginReverseInterface::StreamAsFile_MainThreadContinuation,
291        open_cont);
292    // Normal files.
293    if (!PnaclUrls::IsPnaclComponent(mapped_url)) {
294      if (!plugin_->StreamAsFile(mapped_url,
295                                 stream_cc.pp_completion_callback())) {
296        NaClLog(4,
297                "OpenManifestEntry_MainThreadContinuation: "
298                "StreamAsFile failed\n");
299        nacl::MutexLocker take(&mu_);
300        *p->op_complete_ptr = true;  // done...
301        p->file_info->desc = -1;       // but failed.
302        p->error_info->SetReport(ERROR_MANIFEST_OPEN,
303                                 "ServiceRuntime: StreamAsFile failed");
304        NaClXCondVarBroadcast(&cv_);
305        return;
306      }
307      NaClLog(4,
308              "OpenManifestEntry_MainThreadContinuation: StreamAsFile okay\n");
309    } else {
310      // Special PNaCl support files, that are installed on the
311      // user machine.
312      int32_t fd = PnaclResources::GetPnaclFD(
313          plugin_,
314          PnaclUrls::PnaclComponentURLToFilename(mapped_url).c_str());
315      if (fd < 0) {
316        // We should check earlier if the pnacl component wasn't installed
317        // yet.  At this point, we can't do much anymore, so just continue
318        // with an invalid fd.
319        NaClLog(4,
320                "OpenManifestEntry_MainThreadContinuation: "
321                "GetReadonlyPnaclFd failed\n");
322        // TODO(jvoung): Separate the error codes?
323        p->error_info->SetReport(ERROR_MANIFEST_OPEN,
324                                 "ServiceRuntime: GetPnaclFd failed");
325      }
326      nacl::MutexLocker take(&mu_);
327      *p->op_complete_ptr = true;  // done!
328      // TODO(ncbray): enable the fast loading and validation paths for this
329      // type of file.
330      p->file_info->desc = fd;
331      NaClXCondVarBroadcast(&cv_);
332      NaClLog(4,
333              "OpenManifestEntry_MainThreadContinuation: GetPnaclFd okay\n");
334    }
335  } else {
336    // Requires PNaCl translation.
337    NaClLog(4,
338            "OpenManifestEntry_MainThreadContinuation: "
339            "pulling down and translating.\n");
340    if (plugin_->nacl_interface()->IsPnaclEnabled()) {
341      pp::CompletionCallback translate_callback =
342          WeakRefNewCallback(
343              anchor_,
344              this,
345              &PluginReverseInterface::BitcodeTranslate_MainThreadContinuation,
346              open_cont);
347      // Will always call the callback on success or failure.
348      pnacl_coordinator_.reset(
349          PnaclCoordinator::BitcodeToNative(plugin_,
350                                            mapped_url,
351                                            pnacl_options,
352                                            translate_callback));
353    } else {
354      nacl::MutexLocker take(&mu_);
355      *p->op_complete_ptr = true;  // done...
356      p->file_info->desc = -1;  // but failed.
357      p->error_info->SetReport(ERROR_PNACL_NOT_ENABLED,
358                               "ServiceRuntime: GetPnaclFd failed -- pnacl not "
359                               "enabled with --enable-pnacl.");
360      NaClXCondVarBroadcast(&cv_);
361      return;
362    }
363  }
364  // p is deleted automatically
365}
366
367void PluginReverseInterface::StreamAsFile_MainThreadContinuation(
368    OpenManifestEntryResource* p,
369    int32_t result) {
370  NaClLog(4,
371          "Entered StreamAsFile_MainThreadContinuation\n");
372
373  nacl::MutexLocker take(&mu_);
374  if (result == PP_OK) {
375    NaClLog(4, "StreamAsFile_MainThreadContinuation: GetFileInfo(%s)\n",
376            p->url.c_str());
377    *p->file_info = plugin_->GetFileInfo(p->url);
378
379    NaClLog(4,
380            "StreamAsFile_MainThreadContinuation: PP_OK, desc %d\n",
381            p->file_info->desc);
382  } else {
383    NaClLog(4,
384            "StreamAsFile_MainThreadContinuation: !PP_OK, setting desc -1\n");
385    p->file_info->desc = -1;
386    p->error_info->SetReport(ERROR_MANIFEST_OPEN,
387                             "Plugin StreamAsFile failed at callback");
388  }
389  *p->op_complete_ptr = true;
390  NaClXCondVarBroadcast(&cv_);
391}
392
393
394void PluginReverseInterface::BitcodeTranslate_MainThreadContinuation(
395    OpenManifestEntryResource* p,
396    int32_t result) {
397  NaClLog(4,
398          "Entered BitcodeTranslate_MainThreadContinuation\n");
399
400  nacl::MutexLocker take(&mu_);
401  if (result == PP_OK) {
402    // TODO(jvoung): clean this up. We are assuming that the NaClDesc is
403    // a host IO desc and doing a downcast. Once the ReverseInterface
404    // accepts NaClDescs we can avoid this downcast.
405    NaClDesc* desc = pnacl_coordinator_->ReleaseTranslatedFD()->desc();
406    struct NaClDescIoDesc* ndiodp = (struct NaClDescIoDesc*)desc;
407    p->file_info->desc = ndiodp->hd->d;
408    pnacl_coordinator_.reset(NULL);
409    NaClLog(4,
410            "BitcodeTranslate_MainThreadContinuation: PP_OK, desc %d\n",
411            p->file_info->desc);
412  } else {
413    NaClLog(4,
414            "BitcodeTranslate_MainThreadContinuation: !PP_OK, "
415            "setting desc -1\n");
416    p->file_info->desc = -1;
417    // Error should have been reported by pnacl coordinator.
418    NaClLog(LOG_ERROR, "PluginReverseInterface::BitcodeTranslate error.\n");
419  }
420  *p->op_complete_ptr = true;
421  NaClXCondVarBroadcast(&cv_);
422}
423
424
425bool PluginReverseInterface::CloseManifestEntry(int32_t desc) {
426  bool op_complete = false;
427  bool op_result;
428  CloseManifestEntryResource* to_close =
429      new CloseManifestEntryResource(desc, &op_complete, &op_result);
430
431  bool shutting_down;
432  plugin::WeakRefCallOnMainThread(
433      anchor_,
434      0,
435      this,
436      &plugin::PluginReverseInterface::
437        CloseManifestEntry_MainThreadContinuation,
438      to_close);
439  // wait for completion or surf-away.
440  do {
441    nacl::MutexLocker take(&mu_);
442    for (;;) {
443      shutting_down = shutting_down_;
444      if (op_complete || shutting_down) {
445        break;
446      }
447      NaClXCondVarWait(&cv_, &mu_);
448    }
449  } while (0);
450
451  if (shutting_down) return false;
452  // op_result true if close was successful; false otherwise (e.g., bad desc).
453  return op_result;
454}
455
456void PluginReverseInterface::CloseManifestEntry_MainThreadContinuation(
457    CloseManifestEntryResource* cls,
458    int32_t err) {
459  UNREFERENCED_PARAMETER(err);
460
461  nacl::MutexLocker take(&mu_);
462  // TODO(bsy): once the plugin has a reliable way to report that the
463  // file usage is done -- and sel_ldr uses this RPC call -- we should
464  // tell the plugin that the associated resources can be freed.
465  *cls->op_result_ptr = true;
466  *cls->op_complete_ptr = true;
467  NaClXCondVarBroadcast(&cv_);
468  // cls automatically deleted
469}
470
471void PluginReverseInterface::ReportCrash() {
472  NaClLog(4, "PluginReverseInterface::ReportCrash\n");
473
474  if (crash_cb_.pp_completion_callback().func != NULL) {
475    NaClLog(4, "PluginReverseInterface::ReportCrash: invoking CB\n");
476    pp::Module::Get()->core()->CallOnMainThread(0, crash_cb_, PP_OK);
477  } else {
478    NaClLog(1,
479            "PluginReverseInterface::ReportCrash:"
480            " crash_cb_ not valid, skipping\n");
481  }
482}
483
484void PluginReverseInterface::ReportExitStatus(int exit_status) {
485  service_runtime_->set_exit_status(exit_status);
486}
487
488void PluginReverseInterface::QuotaRequest_MainThreadContinuation(
489    QuotaRequest* request,
490    int32_t err) {
491  if (err != PP_OK) {
492    return;
493  }
494
495  switch (request->data.type) {
496    case plugin::PepperQuotaType: {
497      const PPB_FileIOTrusted* file_io_trusted =
498          static_cast<const PPB_FileIOTrusted*>(
499              pp::Module::Get()->GetBrowserInterface(
500                  PPB_FILEIOTRUSTED_INTERFACE));
501      // Copy the request object because this one will be deleted on return.
502      // copy ctor!
503      QuotaRequest* cont_for_response = new QuotaRequest(*request);
504      pp::CompletionCallback quota_cc = WeakRefNewCallback(
505          anchor_,
506          this,
507          &PluginReverseInterface::QuotaRequest_MainThreadResponse,
508          cont_for_response);
509      file_io_trusted->WillWrite(request->data.resource,
510                                 request->offset,
511                                 // TODO(sehr): remove need for cast.
512                                 // Unify WillWrite interface vs Quota request.
513                                 nacl::assert_cast<int32_t>(
514                                     request->bytes_requested),
515                                 quota_cc.pp_completion_callback());
516      break;
517    }
518    case plugin::TempQuotaType: {
519      uint64_t len = request->offset + request->bytes_requested;
520      nacl::MutexLocker take(&mu_);
521      // Do some crude quota enforcement.
522      if (len > kMaxTempQuota) {
523        *request->bytes_granted = 0;
524      } else {
525        *request->bytes_granted = request->bytes_requested;
526      }
527      *request->op_complete_ptr = true;
528      NaClXCondVarBroadcast(&cv_);
529      break;
530    }
531  }
532  // request automatically deleted
533}
534
535void PluginReverseInterface::QuotaRequest_MainThreadResponse(
536    QuotaRequest* request,
537    int32_t err) {
538  NaClLog(4,
539          "PluginReverseInterface::QuotaRequest_MainThreadResponse:"
540          " (resource=%" NACL_PRIx32 ", offset=%" NACL_PRId64 ", requested=%"
541          NACL_PRId64 ", err=%" NACL_PRId32 ")\n",
542          request->data.resource,
543          request->offset, request->bytes_requested, err);
544  nacl::MutexLocker take(&mu_);
545  if (err >= PP_OK) {
546    *request->bytes_granted = err;
547  } else {
548    *request->bytes_granted = 0;
549  }
550  *request->op_complete_ptr = true;
551  NaClXCondVarBroadcast(&cv_);
552  // request automatically deleted
553}
554
555int64_t PluginReverseInterface::RequestQuotaForWrite(
556    nacl::string file_id, int64_t offset, int64_t bytes_to_write) {
557  NaClLog(4,
558          "PluginReverseInterface::RequestQuotaForWrite:"
559          " (file_id='%s', offset=%" NACL_PRId64 ", bytes_to_write=%"
560          NACL_PRId64 ")\n", file_id.c_str(), offset, bytes_to_write);
561  QuotaData quota_data;
562  {
563    nacl::MutexLocker take(&mu_);
564    uint64_t file_key = STRTOULL(file_id.c_str(), NULL, 10);
565    if (quota_map_.find(file_key) == quota_map_.end()) {
566      // Look up failed to find the requested quota managed resource.
567      NaClLog(4, "PluginReverseInterface::RequestQuotaForWrite: failed...\n");
568      return 0;
569    }
570    quota_data = quota_map_[file_key];
571  }
572  // Variables set by requesting quota.
573  int64_t quota_granted = 0;
574  bool op_complete = false;
575  QuotaRequest* continuation =
576      new QuotaRequest(quota_data, offset, bytes_to_write, &quota_granted,
577                       &op_complete);
578  // The reverse service is running on a background thread and the PPAPI quota
579  // methods must be invoked only from the main thread.
580  plugin::WeakRefCallOnMainThread(
581      anchor_,
582      0,  /* delay in ms */
583      this,
584      &plugin::PluginReverseInterface::QuotaRequest_MainThreadContinuation,
585      continuation);
586  // Wait for the main thread to request quota and signal completion.
587  // It is also possible that the main thread will signal shut down.
588  bool shutting_down;
589  do {
590    nacl::MutexLocker take(&mu_);
591    for (;;) {
592      shutting_down = shutting_down_;
593      if (op_complete || shutting_down) {
594        break;
595      }
596      NaClXCondVarWait(&cv_, &mu_);
597    }
598  } while (0);
599  if (shutting_down) return 0;
600  return quota_granted;
601}
602
603void PluginReverseInterface::AddQuotaManagedFile(const nacl::string& file_id,
604                                                 const pp::FileIO& file_io) {
605  PP_Resource resource = file_io.pp_resource();
606  NaClLog(4,
607          "PluginReverseInterface::AddQuotaManagedFile: "
608          "(file_id='%s', file_io_ref=%" NACL_PRIx32 ")\n",
609          file_id.c_str(), resource);
610  nacl::MutexLocker take(&mu_);
611  uint64_t file_key = STRTOULL(file_id.c_str(), NULL, 10);
612  QuotaData data(plugin::PepperQuotaType, resource);
613  quota_map_[file_key] = data;
614}
615
616void PluginReverseInterface::AddTempQuotaManagedFile(
617    const nacl::string& file_id) {
618  NaClLog(4, "PluginReverseInterface::AddTempQuotaManagedFile: "
619          "(file_id='%s')\n", file_id.c_str());
620  nacl::MutexLocker take(&mu_);
621  uint64_t file_key = STRTOULL(file_id.c_str(), NULL, 10);
622  QuotaData data(plugin::TempQuotaType, 0);
623  quota_map_[file_key] = data;
624}
625
626ServiceRuntime::ServiceRuntime(Plugin* plugin,
627                               const Manifest* manifest,
628                               bool should_report_uma,
629                               pp::CompletionCallback init_done_cb,
630                               pp::CompletionCallback crash_cb)
631    : plugin_(plugin),
632      should_report_uma_(should_report_uma),
633      reverse_service_(NULL),
634      anchor_(new nacl::WeakRefAnchor()),
635      rev_interface_(new PluginReverseInterface(anchor_, plugin,
636                                                manifest,
637                                                this,
638                                                init_done_cb, crash_cb)),
639      exit_status_(-1),
640      start_sel_ldr_done_(false) {
641  NaClSrpcChannelInitialize(&command_channel_);
642  NaClXMutexCtor(&mu_);
643  NaClXCondVarCtor(&cond_);
644}
645
646bool ServiceRuntime::InitCommunication(nacl::DescWrapper* nacl_desc,
647                                       ErrorInfo* error_info) {
648  NaClLog(4, "ServiceRuntime::InitCommunication"
649          " (this=%p, subprocess=%p)\n",
650          static_cast<void*>(this),
651          static_cast<void*>(subprocess_.get()));
652  // Create the command channel to the sel_ldr and load the nexe from nacl_desc.
653  if (!subprocess_->SetupCommandAndLoad(&command_channel_, nacl_desc)) {
654    error_info->SetReport(ERROR_SEL_LDR_COMMUNICATION_CMD_CHANNEL,
655                          "ServiceRuntime: command channel creation failed");
656    return false;
657  }
658  // Hook up the reverse service channel.  We are the IMC client, but
659  // provide SRPC service.
660  NaClDesc* out_conn_cap;
661  NaClSrpcResultCodes rpc_result =
662      NaClSrpcInvokeBySignature(&command_channel_,
663                                "reverse_setup::h",
664                                &out_conn_cap);
665
666  if (NACL_SRPC_RESULT_OK != rpc_result) {
667    error_info->SetReport(ERROR_SEL_LDR_COMMUNICATION_REV_SETUP,
668                          "ServiceRuntime: reverse setup rpc failed");
669    return false;
670  }
671  //  Get connection capability to service runtime where the IMC
672  //  server/SRPC client is waiting for a rendezvous.
673  NaClLog(4, "ServiceRuntime: got 0x%" NACL_PRIxPTR "\n",
674          (uintptr_t) out_conn_cap);
675  nacl::DescWrapper* conn_cap = plugin_->wrapper_factory()->MakeGenericCleanup(
676      out_conn_cap);
677  if (conn_cap == NULL) {
678    error_info->SetReport(ERROR_SEL_LDR_COMMUNICATION_WRAPPER,
679                          "ServiceRuntime: wrapper allocation failure");
680    return false;
681  }
682  out_conn_cap = NULL;  // ownership passed
683  NaClLog(4, "ServiceRuntime::InitCommunication: starting reverse service\n");
684  reverse_service_ = new nacl::ReverseService(conn_cap, rev_interface_->Ref());
685  if (!reverse_service_->Start()) {
686    error_info->SetReport(ERROR_SEL_LDR_COMMUNICATION_REV_SERVICE,
687                          "ServiceRuntime: starting reverse services failed");
688    return false;
689  }
690
691  // start the module.  otherwise we cannot connect for multimedia
692  // subsystem since that is handled by user-level code (not secure!)
693  // in libsrpc.
694  int load_status = -1;
695  rpc_result =
696      NaClSrpcInvokeBySignature(&command_channel_,
697                                "start_module::i",
698                                &load_status);
699
700  if (NACL_SRPC_RESULT_OK != rpc_result) {
701    error_info->SetReport(ERROR_SEL_LDR_START_MODULE,
702                          "ServiceRuntime: could not start nacl module");
703    return false;
704  }
705  NaClLog(4, "ServiceRuntime::InitCommunication (load_status=%d)\n",
706          load_status);
707  if (should_report_uma_) {
708    plugin_->ReportSelLdrLoadStatus(load_status);
709  }
710  if (LOAD_OK != load_status) {
711    error_info->SetReport(
712        ERROR_SEL_LDR_START_STATUS,
713        NaClErrorString(static_cast<NaClErrorCode>(load_status)));
714    return false;
715  }
716  return true;
717}
718
719bool ServiceRuntime::StartSelLdr(const SelLdrStartParams& params) {
720  NaClLog(4, "ServiceRuntime::Start\n");
721
722  nacl::scoped_ptr<SelLdrLauncherChrome>
723      tmp_subprocess(new SelLdrLauncherChrome());
724  if (NULL == tmp_subprocess.get()) {
725    NaClLog(LOG_ERROR, "ServiceRuntime::Start (subprocess create failed)\n");
726    params.error_info->SetReport(
727        ERROR_SEL_LDR_CREATE_LAUNCHER,
728        "ServiceRuntime: failed to create sel_ldr launcher");
729    return false;
730  }
731  nacl::string error_message;
732  bool started = tmp_subprocess->Start(plugin_->pp_instance(),
733                                       params.url.c_str(),
734                                       params.uses_irt,
735                                       params.uses_ppapi,
736                                       params.enable_dev_interfaces,
737                                       params.enable_dyncode_syscalls,
738                                       params.enable_exception_handling,
739                                       &error_message);
740  if (!started) {
741    NaClLog(LOG_ERROR, "ServiceRuntime::Start (start failed)\n");
742    params.error_info->SetReportWithConsoleOnlyError(
743        ERROR_SEL_LDR_LAUNCH,
744        "ServiceRuntime: failed to start",
745        error_message);
746    return false;
747  }
748
749  subprocess_.reset(tmp_subprocess.release());
750  NaClLog(4, "ServiceRuntime::StartSelLdr (return 1)\n");
751  return true;
752}
753
754void ServiceRuntime::WaitForSelLdrStart() {
755  nacl::MutexLocker take(&mu_);
756  while(!start_sel_ldr_done_) {
757    NaClXCondVarWait(&cond_, &mu_);
758  }
759}
760
761void ServiceRuntime::SignalStartSelLdrDone() {
762  nacl::MutexLocker take(&mu_);
763  start_sel_ldr_done_ = true;
764  NaClXCondVarSignal(&cond_);
765}
766
767bool ServiceRuntime::LoadNexeAndStart(nacl::DescWrapper* nacl_desc,
768                                      ErrorInfo* error_info,
769                                      const pp::CompletionCallback& crash_cb) {
770  NaClLog(4, "ServiceRuntime::LoadNexeAndStart (nacl_desc=%p)\n",
771          reinterpret_cast<void*>(nacl_desc));
772  if (!InitCommunication(nacl_desc, error_info)) {
773    // On a load failure the service runtime does not crash itself to
774    // avoid a race where the no-more-senders error on the reverse
775    // channel esrvice thread might cause the crash-detection logic to
776    // kick in before the start_module RPC reply has been received. So
777    // we induce a service runtime crash here. We do not release
778    // subprocess_ since it's needed to collect crash log output after
779    // the error is reported.
780    Log(LOG_FATAL, "reap logs");
781    if (NULL == reverse_service_) {
782      // No crash detector thread.
783      NaClLog(LOG_ERROR, "scheduling to get crash log\n");
784      pp::Module::Get()->core()->CallOnMainThread(0, crash_cb, PP_OK);
785      NaClLog(LOG_ERROR, "should fire soon\n");
786    } else {
787      NaClLog(LOG_ERROR, "Reverse service thread will pick up crash log\n");
788    }
789    return false;
790  }
791
792  NaClLog(4, "ServiceRuntime::LoadNexeAndStart (return 1)\n");
793  return true;
794}
795
796SrpcClient* ServiceRuntime::SetupAppChannel() {
797  NaClLog(4, "ServiceRuntime::SetupAppChannel (subprocess_=%p)\n",
798          reinterpret_cast<void*>(subprocess_.get()));
799  nacl::DescWrapper* connect_desc = subprocess_->socket_addr()->Connect();
800  if (NULL == connect_desc) {
801    NaClLog(LOG_ERROR, "ServiceRuntime::SetupAppChannel (connect failed)\n");
802    return NULL;
803  } else {
804    NaClLog(4, "ServiceRuntime::SetupAppChannel (conect_desc=%p)\n",
805            static_cast<void*>(connect_desc));
806    SrpcClient* srpc_client = SrpcClient::New(connect_desc);
807    NaClLog(4, "ServiceRuntime::SetupAppChannel (srpc_client=%p)\n",
808            static_cast<void*>(srpc_client));
809    delete connect_desc;
810    return srpc_client;
811  }
812}
813
814bool ServiceRuntime::Log(int severity, const nacl::string& msg) {
815  NaClSrpcResultCodes rpc_result =
816      NaClSrpcInvokeBySignature(&command_channel_,
817                                "log:is:",
818                                severity,
819                                strdup(msg.c_str()));
820  return (NACL_SRPC_RESULT_OK == rpc_result);
821}
822
823void ServiceRuntime::Shutdown() {
824  rev_interface_->ShutDown();
825  anchor_->Abandon();
826  // Abandon callbacks, tell service threads to quit if they were
827  // blocked waiting for main thread operations to finish.  Note that
828  // some callbacks must still await their completion event, e.g.,
829  // CallOnMainThread must still wait for the time out, or I/O events
830  // must finish, so resources associated with pending events cannot
831  // be deallocated.
832
833  // Note that this does waitpid() to get rid of any zombie subprocess.
834  subprocess_.reset(NULL);
835
836  NaClSrpcDtor(&command_channel_);
837
838  // subprocess_ has been shut down, but threads waiting on messages
839  // from the service runtime may not have noticed yet.  The low-level
840  // NaClSimpleRevService code takes care to refcount the data objects
841  // that it needs, and reverse_service_ is also refcounted.  We wait
842  // for the service threads to get their EOF indications.
843  if (reverse_service_ != NULL) {
844    reverse_service_->WaitForServiceThreadsToExit();
845    reverse_service_->Unref();
846    reverse_service_ = NULL;
847  }
848}
849
850ServiceRuntime::~ServiceRuntime() {
851  NaClLog(4, "ServiceRuntime::~ServiceRuntime (this=%p)\n",
852          static_cast<void*>(this));
853  // We do this just in case Shutdown() was not called.
854  subprocess_.reset(NULL);
855  if (reverse_service_ != NULL) {
856    reverse_service_->Unref();
857  }
858
859  rev_interface_->Unref();
860
861  anchor_->Unref();
862  NaClCondVarDtor(&cond_);
863  NaClMutexDtor(&mu_);
864}
865
866int ServiceRuntime::exit_status() {
867  nacl::MutexLocker take(&mu_);
868  return exit_status_;
869}
870
871void ServiceRuntime::set_exit_status(int exit_status) {
872  nacl::MutexLocker take(&mu_);
873  exit_status_ = exit_status & 0xff;
874}
875
876nacl::string ServiceRuntime::GetCrashLogOutput() {
877  if (NULL != subprocess_.get()) {
878    return subprocess_->GetCrashLogOutput();
879  } else {
880    return std::string();
881  }
882}
883
884}  // namespace plugin
885