/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "HangDetails.h"

#include "nsIHangDetails.h"
#include "nsPrintfCString.h"
#include "js/Array.h"               // JS::NewArrayObject
#include "js/PropertyAndElement.h"  // JS_DefineElement
#include "mozilla/FileUtils.h"
#include "mozilla/gfx/GPUParent.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/ContentParent.h"  // For RemoteTypePrefix
#include "mozilla/FileUtils.h"
#include "mozilla/SchedulerGroup.h"
#include "mozilla/Unused.h"
#include "mozilla/GfxMessageUtils.h"  // For ParamTraits<GeckoProcessType>
#include "mozilla/ResultExtensions.h"
#include "mozilla/Try.h"
#include "shared-libraries.h"

static const char MAGIC[] = "permahangsavev1";

namespace mozilla {

NS_IMETHODIMP
nsHangDetails::GetWasPersisted(bool* aWasPersisted) {
  *aWasPersisted = mPersistedToDisk == PersistedToDisk::Yes;
  return NS_OK;
}

NS_IMETHODIMP
nsHangDetails::GetDuration(double* aDuration) {
  *aDuration = mDetails.duration().ToMilliseconds();
  return NS_OK;
}

NS_IMETHODIMP
nsHangDetails::GetThread(nsACString& aName) {
  aName.Assign(mDetails.threadName());
  return NS_OK;
}

NS_IMETHODIMP
nsHangDetails::GetRunnableName(nsACString& aRunnableName) {
  aRunnableName.Assign(mDetails.runnableName());
  return NS_OK;
}

NS_IMETHODIMP
nsHangDetails::GetProcess(nsACString& aName) {
  aName.Assign(mDetails.process());
  return NS_OK;
}

NS_IMETHODIMP
nsHangDetails::GetRemoteType(nsACString& aName) {
  aName.Assign(mDetails.remoteType());
  return NS_OK;
}

NS_IMETHODIMP
nsHangDetails::GetAnnotations(JSContext* aCx,
                              JS::MutableHandle<JS::Value> aVal) {
  // We create an Array with ["key", "value"] string pair entries for each item
  // in our annotations object.
  auto& annotations = mDetails.annotations();
  size_t length = annotations.Length();
  JS::Rooted<JSObject*> retObj(aCx, JS::NewArrayObject(aCx, length));
  if (!retObj) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  for (size_t i = 0; i < length; ++i) {
    const auto& annotation = annotations[i];
    JS::Rooted<JSObject*> annotationPair(aCx, JS::NewArrayObject(aCx, 2));
    if (!annotationPair) {
      return NS_ERROR_OUT_OF_MEMORY;
    }

    JS::Rooted<JSString*> key(aCx,
                              JS_NewUCStringCopyN(aCx, annotation.name().get(),
                                                  annotation.name().Length()));
    if (!key) {
      return NS_ERROR_OUT_OF_MEMORY;
    }

    JS::Rooted<JSString*> value(
        aCx, JS_NewUCStringCopyN(aCx, annotation.value().get(),
                                 annotation.value().Length()));
    if (!value) {
      return NS_ERROR_OUT_OF_MEMORY;
    }

    if (!JS_DefineElement(aCx, annotationPair, 0, key, JSPROP_ENUMERATE)) {
      return NS_ERROR_OUT_OF_MEMORY;
    }

    if (!JS_DefineElement(aCx, annotationPair, 1, value, JSPROP_ENUMERATE)) {
      return NS_ERROR_OUT_OF_MEMORY;
    }

    if (!JS_DefineElement(aCx, retObj, i, annotationPair, JSPROP_ENUMERATE)) {
      return NS_ERROR_OUT_OF_MEMORY;
    }
  }

  aVal.setObject(*retObj);
  return NS_OK;
}

namespace {

nsresult StringFrame(JSContext* aCx, JS::RootedObject& aTarget, size_t aIndex,
                     const char* aString) {
  JSString* jsString = JS_NewStringCopyZ(aCx, aString);
  if (!jsString) {
    return NS_ERROR_OUT_OF_MEMORY;
  }
  JS::Rooted<JSString*> string(aCx, jsString);
  if (!string) {
    return NS_ERROR_OUT_OF_MEMORY;
  }
  if (!JS_DefineElement(aCx, aTarget, aIndex, string, JSPROP_ENUMERATE)) {
    return NS_ERROR_OUT_OF_MEMORY;
  }
  return NS_OK;
}

}  // anonymous namespace

NS_IMETHODIMP
nsHangDetails::GetStack(JSContext* aCx, JS::MutableHandle<JS::Value> aStack) {
  auto& stack = mDetails.stack();
  uint32_t length = stack.stack().Length();
  JS::Rooted<JSObject*> ret(aCx, JS::NewArrayObject(aCx, length));
  if (!ret) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  for (uint32_t i = 0; i < length; ++i) {
    auto& entry = stack.stack()[i];
    switch (entry.type()) {
      case HangEntry::TnsCString: {
        nsresult rv = StringFrame(aCx, ret, i, entry.get_nsCString().get());
        NS_ENSURE_SUCCESS(rv, rv);
        break;
      }
      case HangEntry::THangEntryBufOffset: {
        uint32_t offset = entry.get_HangEntryBufOffset().index();

        // NOTE: We can't trust the offset we got, as we might have gotten it
        // from a compromised content process. Validate that it is in bounds.
        if (NS_WARN_IF(stack.strbuffer().IsEmpty() ||
                       offset >= stack.strbuffer().Length())) {
          MOZ_ASSERT_UNREACHABLE("Corrupted offset data");
          return NS_ERROR_FAILURE;
        }

        // NOTE: If our content process is compromised, it could send us back a
        // strbuffer() which didn't have a null terminator. If the last byte in
        // the buffer is not '\0', we abort, to make sure we don't read out of
        // bounds.
        if (stack.strbuffer().LastElement() != '\0') {
          MOZ_ASSERT_UNREACHABLE("Corrupted strbuffer data");
          return NS_ERROR_FAILURE;
        }

        // We know this offset is safe because of the previous checks.
        const int8_t* start = stack.strbuffer().Elements() + offset;
        nsresult rv =
            StringFrame(aCx, ret, i, reinterpret_cast<const char*>(start));
        NS_ENSURE_SUCCESS(rv, rv);
        break;
      }
      case HangEntry::THangEntryModOffset: {
        const HangEntryModOffset& mo = entry.get_HangEntryModOffset();

        JS::Rooted<JSObject*> jsFrame(aCx, JS::NewArrayObject(aCx, 2));
        if (!jsFrame) {
          return NS_ERROR_OUT_OF_MEMORY;
        }

        if (!JS_DefineElement(aCx, jsFrame, 0, mo.module(), JSPROP_ENUMERATE)) {
          return NS_ERROR_OUT_OF_MEMORY;
        }

        nsPrintfCString hexString("%" PRIxPTR, (uintptr_t)mo.offset());
        JS::Rooted<JSString*> hex(aCx, JS_NewStringCopyZ(aCx, hexString.get()));
        if (!hex || !JS_DefineElement(aCx, jsFrame, 1, hex, JSPROP_ENUMERATE)) {
          return NS_ERROR_OUT_OF_MEMORY;
        }

        if (!JS_DefineElement(aCx, ret, i, jsFrame, JSPROP_ENUMERATE)) {
          return NS_ERROR_OUT_OF_MEMORY;
        }
        break;
      }
      case HangEntry::THangEntryProgCounter: {
        // Don't bother recording fixed program counters to JS
        nsresult rv = StringFrame(aCx, ret, i, "(unresolved)");
        NS_ENSURE_SUCCESS(rv, rv);
        break;
      }
      case HangEntry::THangEntryContent: {
        nsresult rv = StringFrame(aCx, ret, i, "(content script)");
        NS_ENSURE_SUCCESS(rv, rv);
        break;
      }
      case HangEntry::THangEntryJit: {
        nsresult rv = StringFrame(aCx, ret, i, "(jit frame)");
        NS_ENSURE_SUCCESS(rv, rv);
        break;
      }
      case HangEntry::THangEntryWasm: {
        nsresult rv = StringFrame(aCx, ret, i, "(wasm)");
        NS_ENSURE_SUCCESS(rv, rv);
        break;
      }
      case HangEntry::THangEntryChromeScript: {
        nsresult rv = StringFrame(aCx, ret, i, "(chrome script)");
        NS_ENSURE_SUCCESS(rv, rv);
        break;
      }
      case HangEntry::THangEntrySuppressed: {
        nsresult rv = StringFrame(aCx, ret, i, "(profiling suppressed)");
        NS_ENSURE_SUCCESS(rv, rv);
        break;
      }
      default:
        MOZ_CRASH("Unsupported HangEntry type?");
    }
  }

  aStack.setObject(*ret);
  return NS_OK;
}

NS_IMETHODIMP
nsHangDetails::GetModules(JSContext* aCx, JS::MutableHandle<JS::Value> aVal) {
  auto& modules = mDetails.stack().modules();
  size_t length = modules.Length();
  JS::Rooted<JSObject*> retObj(aCx, JS::NewArrayObject(aCx, length));
  if (!retObj) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  for (size_t i = 0; i < length; ++i) {
    const HangModule& module = modules[i];
    JS::Rooted<JSObject*> jsModule(aCx, JS::NewArrayObject(aCx, 2));
    if (!jsModule) {
      return NS_ERROR_OUT_OF_MEMORY;
    }

    JS::Rooted<JSString*> name(
        aCx, JS_NewUCStringCopyN(aCx, module.name().BeginReading(),
                                 module.name().Length()));
    if (!JS_DefineElement(aCx, jsModule, 0, name, JSPROP_ENUMERATE)) {
      return NS_ERROR_OUT_OF_MEMORY;
    }

    JS::Rooted<JSString*> breakpadId(
        aCx, JS_NewStringCopyN(aCx, module.breakpadId().BeginReading(),
                               module.breakpadId().Length()));
    if (!JS_DefineElement(aCx, jsModule, 1, breakpadId, JSPROP_ENUMERATE)) {
      return NS_ERROR_OUT_OF_MEMORY;
    }

    if (!JS_DefineElement(aCx, retObj, i, jsModule, JSPROP_ENUMERATE)) {
      return NS_ERROR_OUT_OF_MEMORY;
    }
  }

  aVal.setObject(*retObj);
  return NS_OK;
}

// Processing and submitting the stack as an observer notification.

void nsHangDetails::Submit() {
  RefPtr<nsHangDetails> hangDetails = this;
  nsCOMPtr<nsIRunnable> notifyObservers =
      NS_NewRunnableFunction("NotifyBHRHangObservers", [hangDetails] {
        // The place we need to report the hang to varies depending on process.
        //
        // In child processes, we report the hang to our parent process, while
        // if we're in the parent process, we report a bhr-thread-hang observer
        // notification.
        switch (XRE_GetProcessType()) {
          case GeckoProcessType_Content: {
            auto cc = dom::ContentChild::GetSingleton();
            if (cc) {
              // Use the prefix so we don't get URIs from Fission isolated
              // processes.
              hangDetails->mDetails.remoteType().Assign(
                  dom::RemoteTypePrefix(cc->GetRemoteType()));
              Unused << cc->SendBHRThreadHang(hangDetails->mDetails);
            }
            break;
          }
          case GeckoProcessType_GPU: {
            auto gp = gfx::GPUParent::GetSingleton();
            if (gp) {
              Unused << gp->SendBHRThreadHang(hangDetails->mDetails);
            }
            break;
          }
          case GeckoProcessType_Default: {
            nsCOMPtr<nsIObserverService> os =
                mozilla::services::GetObserverService();
            if (os) {
              os->NotifyObservers(hangDetails, "bhr-thread-hang", nullptr);
            }
            break;
          }
          default:
            // XXX: Consider handling GeckoProcessType_GMPlugin and
            // GeckoProcessType_Plugin?
            NS_WARNING("Unsupported BHR process type - discarding hang.");
            break;
        }
      });

  nsresult rv = SchedulerGroup::Dispatch(notifyObservers.forget());
  MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
}

NS_IMPL_ISUPPORTS(nsHangDetails, nsIHangDetails)

namespace {

// Sorting comparator used by ReadModuleInformation. Sorts PC Frames by their
// PC.
struct PCFrameComparator {
  bool LessThan(HangEntry* const& a, HangEntry* const& b) const {
    return a->get_HangEntryProgCounter().pc() <
           b->get_HangEntryProgCounter().pc();
  }
  bool Equals(HangEntry* const& a, HangEntry* const& b) const {
    return a->get_HangEntryProgCounter().pc() ==
           b->get_HangEntryProgCounter().pc();
  }
};

}  // anonymous namespace

void ReadModuleInformation(HangStack& stack) {
  // modules() should be empty when we start filling it.
  stack.modules().Clear();

#ifdef MOZ_GECKO_PROFILER
  // Create a sorted list of the PCs in the current stack.
  AutoTArray<HangEntry*, 100> frames;
  for (auto& frame : stack.stack()) {
    if (frame.type() == HangEntry::THangEntryProgCounter) {
      frames.AppendElement(&frame);
    }
  }
  PCFrameComparator comparator;
  frames.Sort(comparator);

  SharedLibraryInfo rawModules = SharedLibraryInfo::GetInfoForSelf();
  rawModules.SortByAddress();

  size_t frameIdx = 0;
  for (size_t i = 0; i < rawModules.GetSize(); ++i) {
    const SharedLibrary& info = rawModules.GetEntry(i);
    uintptr_t moduleStart = info.GetStart();
    uintptr_t moduleEnd = info.GetEnd() - 1;
    // the interval is [moduleStart, moduleEnd)

    bool moduleReferenced = false;
    for (; frameIdx < frames.Length(); ++frameIdx) {
      auto& frame = frames[frameIdx];
      uint64_t pc = frame->get_HangEntryProgCounter().pc();
      // We've moved past this frame, let's go to the next one.
      if (pc >= moduleEnd) {
        break;
      }
      if (pc >= moduleStart) {
        uint64_t offset = pc - moduleStart;
        if (NS_WARN_IF(offset > UINT32_MAX)) {
          continue;  // module/offset can only hold 32-bit offsets into shared
                     // libraries.
        }

        // If we found the module, rewrite the Frame entry to instead be a
        // ModOffset one. mModules.Length() will be the index of the module when
        // we append it below, and we set moduleReferenced to true to ensure
        // that we do.
        moduleReferenced = true;
        uint32_t module = stack.modules().Length();
        HangEntryModOffset modOffset(module, static_cast<uint32_t>(offset));
        *frame = modOffset;
      }
    }

    if (moduleReferenced) {
      HangModule module(info.GetDebugName(), info.GetBreakpadId());
      stack.modules().AppendElement(module);
    }
  }
#endif
}

Result<Ok, nsresult> ReadData(PRFileDesc* aFile, void* aPtr, size_t aLength) {
  int32_t readResult = PR_Read(aFile, aPtr, aLength);
  if (readResult < 0 || size_t(readResult) != aLength) {
    return Err(NS_ERROR_FAILURE);
  }
  return Ok();
}

Result<Ok, nsresult> WriteData(PRFileDesc* aFile, void* aPtr, size_t aLength) {
  int32_t writeResult = PR_Write(aFile, aPtr, aLength);
  if (writeResult < 0 || size_t(writeResult) != aLength) {
    return Err(NS_ERROR_FAILURE);
  }
  return Ok();
}

Result<Ok, nsresult> WriteUint(PRFileDesc* aFile, const CheckedUint32& aInt) {
  if (!aInt.isValid()) {
    MOZ_ASSERT_UNREACHABLE("Integer value out of bounds.");
    return Err(NS_ERROR_UNEXPECTED);
  }
  int32_t value = aInt.value();
  MOZ_TRY(WriteData(aFile, (void*)&value, sizeof(value)));
  return Ok();
}

Result<uint32_t, nsresult> ReadUint(PRFileDesc* aFile) {
  int32_t value;
  MOZ_TRY(ReadData(aFile, (void*)&value, sizeof(value)));
  return value;
}

Result<Ok, nsresult> WriteCString(PRFileDesc* aFile, const char* aString) {
  size_t length = strlen(aString);
  MOZ_TRY(WriteUint(aFile, CheckedUint32(length)));
  MOZ_TRY(WriteData(aFile, (void*)aString, length));
  return Ok();
}

template <typename CharT>
Result<Ok, nsresult> WriteTString(PRFileDesc* aFile,
                                  const nsTString<CharT>& aString) {
  MOZ_TRY(WriteUint(aFile, CheckedUint32(aString.Length())));
  size_t size = aString.Length() * sizeof(CharT);
  MOZ_TRY(WriteData(aFile, (void*)aString.get(), size));
  return Ok();
}

template <typename CharT>
Result<nsTString<CharT>, nsresult> ReadTString(PRFileDesc* aFile) {
  uint32_t length;
  MOZ_TRY_VAR(length, ReadUint(aFile));
  nsTString<CharT> result;
  CharT buffer[512];
  size_t bufferLength = sizeof(buffer) / sizeof(CharT);
  while (length != 0) {
    size_t toRead = std::min(bufferLength, size_t(length));
    size_t toReadSize = toRead * sizeof(CharT);
    MOZ_TRY(ReadData(aFile, (void*)buffer, toReadSize));

    if (!result.Append(buffer, toRead, mozilla::fallible)) {
      return Err(NS_ERROR_FAILURE);
    }

    if (length > bufferLength) {
      length -= bufferLength;
    } else {
      length = 0;
    }
  }
  return result;
}

Result<Ok, nsresult> WriteEntry(PRFileDesc* aFile, const HangStack& aStack,
                                const HangEntry& aEntry) {
  MOZ_TRY(WriteUint(aFile, uint32_t(aEntry.type())));
  switch (aEntry.type()) {
    case HangEntry::TnsCString: {
      MOZ_TRY(WriteTString(aFile, aEntry.get_nsCString()));
      break;
    }
    case HangEntry::THangEntryBufOffset: {
      uint32_t offset = aEntry.get_HangEntryBufOffset().index();

      if (NS_WARN_IF(aStack.strbuffer().IsEmpty() ||
                     offset >= aStack.strbuffer().Length())) {
        MOZ_ASSERT_UNREACHABLE("Corrupted offset data");
        return Err(NS_ERROR_FAILURE);
      }

      if (aStack.strbuffer().LastElement() != '\0') {
        MOZ_ASSERT_UNREACHABLE("Corrupted strbuffer data");
        return Err(NS_ERROR_FAILURE);
      }

      const char* start = (const char*)aStack.strbuffer().Elements() + offset;
      MOZ_TRY(WriteCString(aFile, start));
      break;
    }
    case HangEntry::THangEntryModOffset: {
      const HangEntryModOffset& mo = aEntry.get_HangEntryModOffset();

      MOZ_TRY(WriteUint(aFile, CheckedUint32(mo.module())));
      MOZ_TRY(WriteUint(aFile, CheckedUint32(mo.offset())));
      break;
    }
    case HangEntry::THangEntryProgCounter:
    case HangEntry::THangEntryContent:
    case HangEntry::THangEntryJit:
    case HangEntry::THangEntryWasm:
    case HangEntry::THangEntryChromeScript:
    case HangEntry::THangEntrySuppressed: {
      break;
    }
    default:
      MOZ_CRASH("Unsupported HangEntry type?");
  }
  return Ok();
}

Result<Ok, nsresult> ReadEntry(PRFileDesc* aFile, HangStack& aStack) {
  uint32_t type;
  MOZ_TRY_VAR(type, ReadUint(aFile));
  HangEntry::Type entryType = HangEntry::Type(type);
  switch (entryType) {
    case HangEntry::TnsCString:
    case HangEntry::THangEntryBufOffset: {
      nsCString str;
      MOZ_TRY_VAR(str, ReadTString<char>(aFile));
      aStack.stack().AppendElement(std::move(str));
      break;
    }
    case HangEntry::THangEntryModOffset: {
      uint32_t module;
      MOZ_TRY_VAR(module, ReadUint(aFile));
      uint32_t offset;
      MOZ_TRY_VAR(offset, ReadUint(aFile));
      aStack.stack().AppendElement(HangEntryModOffset(module, offset));
      break;
    }
    case HangEntry::THangEntryProgCounter: {
      aStack.stack().AppendElement(HangEntryProgCounter());
      break;
    }
    case HangEntry::THangEntryContent: {
      aStack.stack().AppendElement(HangEntryContent());
      break;
    }
    case HangEntry::THangEntryJit: {
      aStack.stack().AppendElement(HangEntryJit());
      break;
    }
    case HangEntry::THangEntryWasm: {
      aStack.stack().AppendElement(HangEntryWasm());
      break;
    }
    case HangEntry::THangEntryChromeScript: {
      aStack.stack().AppendElement(HangEntryChromeScript());
      break;
    }
    case HangEntry::THangEntrySuppressed: {
      aStack.stack().AppendElement(HangEntrySuppressed());
      break;
    }
    default:
      return Err(NS_ERROR_UNEXPECTED);
  }
  return Ok();
}

Result<HangDetails, nsresult> ReadHangDetailsFromFile(nsIFile* aFile) {
  AutoFDClose raiiFd;
  nsresult rv =
      aFile->OpenNSPRFileDesc(PR_RDONLY, 0644, getter_Transfers(raiiFd));
  const auto fd = raiiFd.get();
  if (NS_FAILED(rv)) {
    return Err(rv);
  }

  uint8_t magicBuffer[sizeof(MAGIC)];
  MOZ_TRY(ReadData(fd, (void*)magicBuffer, sizeof(MAGIC)));

  if (memcmp(magicBuffer, MAGIC, sizeof(MAGIC)) != 0) {
    return Err(NS_ERROR_FAILURE);
  }

  HangDetails result;
  uint32_t duration;
  MOZ_TRY_VAR(duration, ReadUint(fd));
  result.duration() = TimeDuration::FromMilliseconds(double(duration));
  MOZ_TRY_VAR(result.threadName(), ReadTString<char>(fd));
  MOZ_TRY_VAR(result.runnableName(), ReadTString<char>(fd));
  MOZ_TRY_VAR(result.process(), ReadTString<char>(fd));
  MOZ_TRY_VAR(result.remoteType(), ReadTString<char>(fd));

  uint32_t numAnnotations;
  MOZ_TRY_VAR(numAnnotations, ReadUint(fd));
  auto& annotations = result.annotations();

  // Add a "Unrecovered" annotation so we can know when processing this that
  // the hang persisted until the process was closed.
  if (!annotations.SetCapacity(numAnnotations + 1, mozilla::fallible)) {
    return Err(NS_ERROR_FAILURE);
  }
  annotations.AppendElement(HangAnnotation(u"Unrecovered"_ns, u"true"_ns));

  for (size_t i = 0; i < numAnnotations; ++i) {
    HangAnnotation annot;
    MOZ_TRY_VAR(annot.name(), ReadTString<char16_t>(fd));
    MOZ_TRY_VAR(annot.value(), ReadTString<char16_t>(fd));
    annotations.AppendElement(std::move(annot));
  }

  auto& stack = result.stack();
  uint32_t numFrames;
  MOZ_TRY_VAR(numFrames, ReadUint(fd));
  if (!stack.stack().SetCapacity(numFrames, mozilla::fallible)) {
    return Err(NS_ERROR_FAILURE);
  }

  for (size_t i = 0; i < numFrames; ++i) {
    MOZ_TRY(ReadEntry(fd, stack));
  }

  uint32_t numModules;
  MOZ_TRY_VAR(numModules, ReadUint(fd));
  auto& modules = stack.modules();
  if (!annotations.SetCapacity(numModules, mozilla::fallible)) {
    return Err(NS_ERROR_FAILURE);
  }

  for (size_t i = 0; i < numModules; ++i) {
    HangModule module;
    MOZ_TRY_VAR(module.name(), ReadTString<char16_t>(fd));
    MOZ_TRY_VAR(module.breakpadId(), ReadTString<char>(fd));
    modules.AppendElement(std::move(module));
  }

  return result;
}

Result<Ok, nsresult> WriteHangDetailsToFile(HangDetails& aDetails,
                                            nsIFile* aFile) {
  if (NS_WARN_IF(!aFile)) {
    return Err(NS_ERROR_INVALID_POINTER);
  }

  AutoFDClose raiiFd;
  nsresult rv = aFile->OpenNSPRFileDesc(
      PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE, 0644, getter_Transfers(raiiFd));
  const auto fd = raiiFd.get();

  if (NS_FAILED(rv)) {
    return Err(rv);
  }

  MOZ_TRY(WriteData(fd, (void*)MAGIC, sizeof(MAGIC)));

  double duration = aDetails.duration().ToMilliseconds();
  if (duration > double(std::numeric_limits<uint32_t>::max())) {
    // Something has gone terribly wrong if we've hung for more than 2^32 ms.
    return Err(NS_ERROR_FAILURE);
  }

  MOZ_TRY(WriteUint(fd, uint32_t(duration)));
  MOZ_TRY(WriteTString(fd, aDetails.threadName()));
  MOZ_TRY(WriteTString(fd, aDetails.runnableName()));
  MOZ_TRY(WriteTString(fd, aDetails.process()));
  MOZ_TRY(WriteTString(fd, aDetails.remoteType()));
  MOZ_TRY(WriteUint(fd, CheckedUint32(aDetails.annotations().Length())));

  for (auto& annot : aDetails.annotations()) {
    MOZ_TRY(WriteTString(fd, annot.name()));
    MOZ_TRY(WriteTString(fd, annot.value()));
  }

  auto& stack = aDetails.stack();
  ReadModuleInformation(stack);

  MOZ_TRY(WriteUint(fd, CheckedUint32(stack.stack().Length())));
  for (auto& entry : stack.stack()) {
    MOZ_TRY(WriteEntry(fd, stack, entry));
  }

  auto& modules = stack.modules();
  MOZ_TRY(WriteUint(fd, CheckedUint32(modules.Length())));

  for (auto& module : modules) {
    MOZ_TRY(WriteTString(fd, module.name()));
    MOZ_TRY(WriteTString(fd, module.breakpadId()));
  }

  return Ok();
}

NS_IMETHODIMP
ProcessHangStackRunnable::Run() {
  // NOTE: Reading module information can take a long time, which is why we do
  // it off-main-thread.
  if (mHangDetails.stack().modules().IsEmpty()) {
    ReadModuleInformation(mHangDetails.stack());
  }

  RefPtr<nsHangDetails> hangDetails =
      new nsHangDetails(std::move(mHangDetails), mPersistedToDisk);
  hangDetails->Submit();

  return NS_OK;
}

NS_IMETHODIMP
SubmitPersistedPermahangRunnable::Run() {
  auto hangDetailsResult = ReadHangDetailsFromFile(mPermahangFile);
  if (hangDetailsResult.isErr()) {
    // If we somehow failed in trying to deserialize the hang file, go ahead
    // and delete it to prevent future runs from having to go through the
    // same thing. If we succeeded, however, the file should be cleaned up
    // once the hang is submitted.
    Unused << mPermahangFile->Remove(false);
    return hangDetailsResult.unwrapErr();
  }
  RefPtr<nsHangDetails> hangDetails =
      new nsHangDetails(hangDetailsResult.unwrap(), PersistedToDisk::Yes);
  hangDetails->Submit();

  return NS_OK;
}

}  // namespace mozilla