Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: sw=2 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
#include "mozilla/ipc/MessageLink.h"
#include "mojo/core/ports/event.h"
#include "mojo/core/ports/node.h"
#include "mozilla/ipc/MessageChannel.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/NodeController.h"
#include "chrome/common/ipc_channel.h"
#include "base/task.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;
namespace mozilla {
namespace ipc {
const char* StringFromIPCSide(Side side) {
switch (side) {
case ChildSide:
return "Child";
case ParentSide:
return "Parent";
default:
return "Unknown";
}
}
MessageLink::MessageLink(MessageChannel* aChan) : mChan(aChan) {}
MessageLink::~MessageLink() {
#ifdef DEBUG
mChan = nullptr;
#endif
}
class PortLink::PortObserverThunk : public NodeController::PortObserver {
public:
PortObserverThunk(RefCountedMonitor* aMonitor, PortLink* aLink)
: mMonitor(aMonitor), mLink(aLink) {}
void OnPortStatusChanged() override {
MonitorAutoLock lock(*mMonitor);
if (mLink) {
mLink->OnPortStatusChanged();
}
}
private:
friend class PortLink;
// The monitor from our PortLink's MessageChannel. Guards access to `mLink`.
RefPtr<RefCountedMonitor> mMonitor;
// Cleared by `PortLink` in `PortLink::Clear()`.
PortLink* MOZ_NON_OWNING_REF mLink;
};
PortLink::PortLink(MessageChannel* aChan, ScopedPort aPort)
: MessageLink(aChan), mNode(aPort.Controller()), mPort(aPort.Release()) {
mChan->mMonitor->AssertCurrentThreadOwns();
mObserver = new PortObserverThunk(mChan->mMonitor, this);
mNode->SetPortObserver(mPort, mObserver);
// Dispatch an event to the IO loop to trigger an initial
// `OnPortStatusChanged` to deliver any pending messages. This needs to be run
// asynchronously from a different thread (or in the case of a same-thread
// channel, from the current thread), for now due to assertions in
// `MessageChannel`.
nsCOMPtr<nsIRunnable> openRunnable = NewRunnableMethod(
"PortLink::Open", mObserver, &PortObserverThunk::OnPortStatusChanged);
if (aChan->mIsSameThreadChannel) {
aChan->mWorkerThread->Dispatch(openRunnable.forget());
} else {
XRE_GetAsyncIOEventTarget()->Dispatch(openRunnable.forget());
}
}
PortLink::~PortLink() {
MOZ_RELEASE_ASSERT(!mObserver, "PortLink destroyed without being closed!");
}
void PortLink::SendMessage(UniquePtr<Message> aMessage) {
mChan->mMonitor->AssertCurrentThreadOwns();
if (aMessage->size() > IPC::Channel::kMaximumMessageSize) {
CrashReporter::RecordAnnotationCString(
CrashReporter::Annotation::IPCMessageName, aMessage->name());
CrashReporter::RecordAnnotationU32(
CrashReporter::Annotation::IPCMessageSize, aMessage->size());
CrashReporter::RecordAnnotationU32(
CrashReporter::Annotation::IPCMessageLargeBufferShmemFailureSize,
aMessage->LargeBufferShmemFailureSize());
MOZ_CRASH("IPC message size is too large");
}
aMessage->AssertAsLargeAsHeader();
RefPtr<PortObserverThunk> observer = mObserver;
if (!observer) {
NS_WARNING("Ignoring message to closed PortLink");
return;
}
// Make local copies of relevant member variables, so we can unlock the
// monitor for the rest of this function. This protects us in case `this` is
// deleted during the call (although that shouldn't happen in practice).
//
// We don't want the monitor to be held when calling into ports, as we may be
// re-entrantly called by our `PortObserverThunk` which will attempt to
// acquire the monitor.
RefPtr<RefCountedMonitor> monitor = mChan->mMonitor;
RefPtr<NodeController> node = mNode;
PortRef port = mPort;
bool ok = false;
monitor->AssertCurrentThreadOwns();
{
MonitorAutoUnlock guard(*monitor);
ok = node->SendUserMessage(port, std::move(aMessage));
}
if (!ok) {
// The send failed, but double-check that we weren't closed racily while
// sending, which could lead to an invalid state error.
if (observer->mLink) {
MOZ_CRASH("Invalid argument to SendUserMessage");
}
NS_WARNING("Message dropped as PortLink was closed");
}
}
void PortLink::Close() {
mChan->mMonitor->AssertCurrentThreadOwns();
if (!mObserver) {
// We're already being closed.
return;
}
Clear();
}
void PortLink::Clear() {
mChan->mMonitor->AssertCurrentThreadOwns();
// NOTE: We're calling into `ports` with our monitor held! Usually, this could
// lead to deadlocks due to the PortObserverThunk acquiring the lock
// re-entrantly, but is OK here as we're immediately clearing the port's
// observer. We shouldn't have issues with any re-entrant calls on this thread
// acquiring this MessageChannel's monitor.
//
// We also clear out the reference in `mObserver` back to this type so that
// notifications from other threads won't try to call us again once we release
// the monitor.
mNode->SetPortObserver(mPort, nullptr);
mObserver->mLink = nullptr;
mObserver = nullptr;
mNode->ClosePort(mPort);
}
void PortLink::OnPortStatusChanged() {
mChan->mMonitor->AssertCurrentThreadOwns();
// Check if the port's remoteness status has updated, and tell our channel if
// it has.
if (Maybe<PortStatus> status = mNode->GetStatus(mPort);
status && status->peer_remote != mChan->IsCrossProcess()) {
mChan->SetIsCrossProcess(status->peer_remote);
}
while (mObserver) {
UniquePtr<IPC::Message> message;
if (!mNode->GetMessage(mPort, &message)) {
Clear();
mChan->OnChannelErrorFromLink();
return;
}
if (!message) {
return;
}
mChan->OnMessageReceivedFromLink(std::move(message));
}
}
bool PortLink::IsClosed() const {
if (Maybe<PortStatus> status = mNode->GetStatus(mPort)) {
return !(status->has_messages || status->receiving_messages);
}
return true;
}
} // namespace ipc
} // namespace mozilla