mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-19 16:25:38 +00:00
15adf94f4d
This introduces the machinery needed to generate crash annotations from a YAML file. The relevant C++ functions are updated to take a typed enum. JavaScript calls are unaffected but they will throw if the string argument does not correspond to one of the known entries in the C++ enum. The existing whitelists and blacklists of annotations are also generated from the YAML file and all duplicate code related to them has been consolidated. Once written out to the .extra file the annotations are converted in string form and are no different than the existing ones. All existing annotations have been included in the list (and some obsolete ones have been removed) and all call sites have been updated including tests where appropriate. --HG-- extra : source : 4f6c43f2830701ec5552e08e3f1b06fe6d045860
434 lines
11 KiB
C++
434 lines
11 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: sw=4 ts=4 et :
|
|
*/
|
|
/* 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 "mozilla/ipc/MessageLink.h"
|
|
#include "mozilla/ipc/MessageChannel.h"
|
|
#include "mozilla/ipc/BrowserProcessSubThread.h"
|
|
#include "mozilla/ipc/ProtocolUtils.h"
|
|
#include "chrome/common/ipc_channel.h"
|
|
|
|
#include "mozilla/Assertions.h"
|
|
#include "mozilla/DebugOnly.h"
|
|
#include "nsDebug.h"
|
|
#include "nsExceptionHandler.h"
|
|
#include "nsISupportsImpl.h"
|
|
#include "nsPrintfCString.h"
|
|
#include "nsXULAppAPI.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace std;
|
|
|
|
// We rely on invariants about the lifetime of the transport:
|
|
//
|
|
// - outlives this MessageChannel
|
|
// - deleted on the IO thread
|
|
//
|
|
// These invariants allow us to send messages directly through the
|
|
// transport without having to worry about orphaned Send() tasks on
|
|
// the IO thread touching MessageChannel memory after it's been deleted
|
|
// on the worker thread. We also don't need to refcount the
|
|
// Transport, because whatever task triggers its deletion only runs on
|
|
// the IO thread, and only runs after this MessageChannel is done with
|
|
// the Transport.
|
|
|
|
namespace mozilla {
|
|
namespace ipc {
|
|
|
|
MessageLink::MessageLink(MessageChannel *aChan)
|
|
: mChan(aChan)
|
|
{
|
|
}
|
|
|
|
MessageLink::~MessageLink()
|
|
{
|
|
#ifdef DEBUG
|
|
mChan = nullptr;
|
|
#endif
|
|
}
|
|
|
|
ProcessLink::ProcessLink(MessageChannel *aChan)
|
|
: MessageLink(aChan)
|
|
, mTransport(nullptr)
|
|
, mIOLoop(nullptr)
|
|
, mExistingListener(nullptr)
|
|
{
|
|
}
|
|
|
|
ProcessLink::~ProcessLink()
|
|
{
|
|
#ifdef DEBUG
|
|
mTransport = nullptr;
|
|
mIOLoop = nullptr;
|
|
mExistingListener = nullptr;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
ProcessLink::Open(mozilla::ipc::Transport* aTransport, MessageLoop *aIOLoop, Side aSide)
|
|
{
|
|
mChan->AssertWorkerThread();
|
|
|
|
MOZ_ASSERT(aTransport, "need transport layer");
|
|
|
|
// FIXME need to check for valid channel
|
|
|
|
mTransport = aTransport;
|
|
|
|
// FIXME figure out whether we're in parent or child, grab IO loop
|
|
// appropriately
|
|
bool needOpen = true;
|
|
if(aIOLoop) {
|
|
// We're a child or using the new arguments. Either way, we
|
|
// need an open.
|
|
needOpen = true;
|
|
mChan->mSide = (aSide == UnknownSide) ? ChildSide : aSide;
|
|
} else {
|
|
MOZ_ASSERT(aSide == UnknownSide, "expected default side arg");
|
|
|
|
// parent
|
|
mChan->mSide = ParentSide;
|
|
needOpen = false;
|
|
aIOLoop = XRE_GetIOMessageLoop();
|
|
}
|
|
|
|
mIOLoop = aIOLoop;
|
|
|
|
NS_ASSERTION(mIOLoop, "need an IO loop");
|
|
NS_ASSERTION(mChan->mWorkerLoop, "need a worker loop");
|
|
|
|
// If we were never able to open the transport, immediately post an error message.
|
|
if (mTransport->Unsound_IsClosed()) {
|
|
mIOLoop->PostTask(
|
|
NewNonOwningRunnableMethod("ipc::ProcessLink::OnChannelConnectError",
|
|
this,
|
|
&ProcessLink::OnChannelConnectError));
|
|
return;
|
|
}
|
|
|
|
{
|
|
MonitorAutoLock lock(*mChan->mMonitor);
|
|
|
|
if (needOpen) {
|
|
// Transport::Connect() has not been called. Call it so
|
|
// we start polling our pipe and processing outgoing
|
|
// messages.
|
|
mIOLoop->PostTask(
|
|
NewNonOwningRunnableMethod("ipc::ProcessLink::OnChannelOpened",
|
|
this,
|
|
&ProcessLink::OnChannelOpened));
|
|
} else {
|
|
// Transport::Connect() has already been called. Take
|
|
// over the channel from the previous listener and process
|
|
// any queued messages.
|
|
mIOLoop->PostTask(NewNonOwningRunnableMethod(
|
|
"ipc::ProcessLink::OnTakeConnectedChannel",
|
|
this,
|
|
&ProcessLink::OnTakeConnectedChannel));
|
|
}
|
|
|
|
// Wait until one of the runnables above changes the state of the
|
|
// channel. Note that the state could be changed again after that (to
|
|
// ChannelClosing, for example, by the IO thread). We can rely on it not
|
|
// changing back to Closed: only the worker thread changes it to closed,
|
|
// and we're on the worker thread, blocked.
|
|
while (mChan->mChannelState == ChannelClosed) {
|
|
mChan->mMonitor->Wait();
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ProcessLink::EchoMessage(Message *msg)
|
|
{
|
|
mChan->AssertWorkerThread();
|
|
mChan->mMonitor->AssertCurrentThreadOwns();
|
|
|
|
mIOLoop->PostTask(
|
|
NewNonOwningRunnableMethod<Message*>("ipc::ProcessLink::OnEchoMessage",
|
|
this,
|
|
&ProcessLink::OnEchoMessage,
|
|
msg));
|
|
// OnEchoMessage takes ownership of |msg|
|
|
}
|
|
|
|
void
|
|
ProcessLink::SendMessage(Message *msg)
|
|
{
|
|
if (msg->size() > IPC::Channel::kMaximumMessageSize) {
|
|
CrashReporter::AnnotateCrashReport(
|
|
CrashReporter::Annotation::IPCMessageName,
|
|
nsDependentCString(msg->name()));
|
|
CrashReporter::AnnotateCrashReport(
|
|
CrashReporter::Annotation::IPCMessageSize,
|
|
static_cast<int>(msg->size()));
|
|
MOZ_CRASH("IPC message size is too large");
|
|
}
|
|
|
|
if (!mChan->mIsPostponingSends) {
|
|
mChan->AssertWorkerThread();
|
|
}
|
|
mChan->mMonitor->AssertCurrentThreadOwns();
|
|
|
|
mIOLoop->PostTask(NewNonOwningRunnableMethod<Message*>(
|
|
"IPC::Channel::Send", mTransport, &Transport::Send, msg));
|
|
}
|
|
|
|
void
|
|
ProcessLink::SendClose()
|
|
{
|
|
mChan->AssertWorkerThread();
|
|
mChan->mMonitor->AssertCurrentThreadOwns();
|
|
|
|
mIOLoop->PostTask(NewNonOwningRunnableMethod(
|
|
"ipc::ProcessLink::OnCloseChannel", this, &ProcessLink::OnCloseChannel));
|
|
}
|
|
|
|
ThreadLink::ThreadLink(MessageChannel *aChan, MessageChannel *aTargetChan)
|
|
: MessageLink(aChan),
|
|
mTargetChan(aTargetChan)
|
|
{
|
|
}
|
|
|
|
ThreadLink::~ThreadLink()
|
|
{
|
|
MOZ_ASSERT(mChan);
|
|
MOZ_ASSERT(mChan->mMonitor);
|
|
MonitorAutoLock lock(*mChan->mMonitor);
|
|
|
|
// Bug 848949: We need to prevent the other side
|
|
// from sending us any more messages to avoid Use-After-Free.
|
|
// The setup here is as shown:
|
|
//
|
|
// (Us) (Them)
|
|
// MessageChannel MessageChannel
|
|
// | ^ \ / ^ |
|
|
// | | X | |
|
|
// v | / \ | v
|
|
// ThreadLink ThreadLink
|
|
//
|
|
// We want to null out the diagonal link from their ThreadLink
|
|
// to our MessageChannel. Note that we must hold the monitor so
|
|
// that we do this atomically with respect to them trying to send
|
|
// us a message. Since the channels share the same monitor this
|
|
// also protects against the two ~ThreadLink() calls racing.
|
|
if (mTargetChan) {
|
|
MOZ_ASSERT(mTargetChan->mLink);
|
|
static_cast<ThreadLink*>(mTargetChan->mLink)->mTargetChan = nullptr;
|
|
}
|
|
mTargetChan = nullptr;
|
|
}
|
|
|
|
void
|
|
ThreadLink::EchoMessage(Message *msg)
|
|
{
|
|
mChan->AssertWorkerThread();
|
|
mChan->mMonitor->AssertCurrentThreadOwns();
|
|
|
|
mChan->OnMessageReceivedFromLink(std::move(*msg));
|
|
delete msg;
|
|
}
|
|
|
|
void
|
|
ThreadLink::SendMessage(Message *msg)
|
|
{
|
|
if (!mChan->mIsPostponingSends) {
|
|
mChan->AssertWorkerThread();
|
|
}
|
|
mChan->mMonitor->AssertCurrentThreadOwns();
|
|
|
|
if (mTargetChan)
|
|
mTargetChan->OnMessageReceivedFromLink(std::move(*msg));
|
|
delete msg;
|
|
}
|
|
|
|
void
|
|
ThreadLink::SendClose()
|
|
{
|
|
mChan->AssertWorkerThread();
|
|
mChan->mMonitor->AssertCurrentThreadOwns();
|
|
|
|
mChan->mChannelState = ChannelClosed;
|
|
|
|
// In a ProcessLink, we would close our half the channel. This
|
|
// would show up on the other side as an error on the I/O thread.
|
|
// The I/O thread would then invoke OnChannelErrorFromLink().
|
|
// As usual, we skip that process and just invoke the
|
|
// OnChannelErrorFromLink() method directly.
|
|
if (mTargetChan)
|
|
mTargetChan->OnChannelErrorFromLink();
|
|
}
|
|
|
|
bool
|
|
ThreadLink::Unsound_IsClosed() const
|
|
{
|
|
MonitorAutoLock lock(*mChan->mMonitor);
|
|
return mChan->mChannelState == ChannelClosed;
|
|
}
|
|
|
|
uint32_t
|
|
ThreadLink::Unsound_NumQueuedMessages() const
|
|
{
|
|
// ThreadLinks don't have a message queue.
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// The methods below run in the context of the IO thread
|
|
//
|
|
|
|
void
|
|
ProcessLink::OnMessageReceived(Message&& msg)
|
|
{
|
|
AssertIOThread();
|
|
NS_ASSERTION(mChan->mChannelState != ChannelError, "Shouldn't get here!");
|
|
MonitorAutoLock lock(*mChan->mMonitor);
|
|
mChan->OnMessageReceivedFromLink(std::move(msg));
|
|
}
|
|
|
|
void
|
|
ProcessLink::OnEchoMessage(Message* msg)
|
|
{
|
|
AssertIOThread();
|
|
OnMessageReceived(std::move(*msg));
|
|
delete msg;
|
|
}
|
|
|
|
void
|
|
ProcessLink::OnChannelOpened()
|
|
{
|
|
AssertIOThread();
|
|
|
|
{
|
|
MonitorAutoLock lock(*mChan->mMonitor);
|
|
|
|
mExistingListener = mTransport->set_listener(this);
|
|
#ifdef DEBUG
|
|
if (mExistingListener) {
|
|
std::queue<Message> pending;
|
|
mExistingListener->GetQueuedMessages(pending);
|
|
MOZ_ASSERT(pending.empty());
|
|
}
|
|
#endif // DEBUG
|
|
|
|
mChan->mChannelState = ChannelOpening;
|
|
lock.Notify();
|
|
}
|
|
/*assert*/mTransport->Connect();
|
|
}
|
|
|
|
void
|
|
ProcessLink::OnTakeConnectedChannel()
|
|
{
|
|
AssertIOThread();
|
|
|
|
std::queue<Message> pending;
|
|
{
|
|
MonitorAutoLock lock(*mChan->mMonitor);
|
|
|
|
mChan->mChannelState = ChannelConnected;
|
|
|
|
mExistingListener = mTransport->set_listener(this);
|
|
if (mExistingListener) {
|
|
mExistingListener->GetQueuedMessages(pending);
|
|
}
|
|
lock.Notify();
|
|
}
|
|
|
|
// Dispatch whatever messages the previous listener had queued up.
|
|
while (!pending.empty()) {
|
|
OnMessageReceived(std::move(pending.front()));
|
|
pending.pop();
|
|
}
|
|
}
|
|
|
|
void
|
|
ProcessLink::OnChannelConnected(int32_t peer_pid)
|
|
{
|
|
AssertIOThread();
|
|
|
|
bool notifyChannel = false;
|
|
|
|
{
|
|
MonitorAutoLock lock(*mChan->mMonitor);
|
|
// Do not force it into connected if it has errored out, started
|
|
// closing, etc. Note that we can be in the Connected state already
|
|
// since the parent starts out Connected.
|
|
if (mChan->mChannelState == ChannelOpening ||
|
|
mChan->mChannelState == ChannelConnected)
|
|
{
|
|
mChan->mChannelState = ChannelConnected;
|
|
mChan->mMonitor->Notify();
|
|
notifyChannel = true;
|
|
}
|
|
}
|
|
|
|
if (mExistingListener) {
|
|
mExistingListener->OnChannelConnected(peer_pid);
|
|
}
|
|
|
|
if (notifyChannel) {
|
|
mChan->OnChannelConnected(peer_pid);
|
|
}
|
|
}
|
|
|
|
void
|
|
ProcessLink::OnChannelConnectError()
|
|
{
|
|
AssertIOThread();
|
|
|
|
MonitorAutoLock lock(*mChan->mMonitor);
|
|
|
|
mChan->OnChannelErrorFromLink();
|
|
}
|
|
|
|
void
|
|
ProcessLink::OnChannelError()
|
|
{
|
|
AssertIOThread();
|
|
|
|
MonitorAutoLock lock(*mChan->mMonitor);
|
|
|
|
MOZ_ALWAYS_TRUE(this == mTransport->set_listener(mExistingListener));
|
|
|
|
mChan->OnChannelErrorFromLink();
|
|
}
|
|
|
|
void
|
|
ProcessLink::OnCloseChannel()
|
|
{
|
|
AssertIOThread();
|
|
|
|
mTransport->Close();
|
|
|
|
MonitorAutoLock lock(*mChan->mMonitor);
|
|
|
|
DebugOnly<IPC::Channel::Listener*> previousListener =
|
|
mTransport->set_listener(mExistingListener);
|
|
|
|
// OnChannelError may have reset the listener already.
|
|
MOZ_ASSERT(previousListener == this ||
|
|
previousListener == mExistingListener);
|
|
|
|
mChan->mChannelState = ChannelClosed;
|
|
mChan->mMonitor->Notify();
|
|
}
|
|
|
|
bool
|
|
ProcessLink::Unsound_IsClosed() const
|
|
{
|
|
return mTransport->Unsound_IsClosed();
|
|
}
|
|
|
|
uint32_t
|
|
ProcessLink::Unsound_NumQueuedMessages() const
|
|
{
|
|
return mTransport->Unsound_NumQueuedMessages();
|
|
}
|
|
|
|
} // namespace ipc
|
|
} // namespace mozilla
|