23748668d3
the deadlock would happen when the pipe became invalid and SF trying to remove the connection from its list. we know make sure to process events without holding a lock. Change-Id: I39927ed8824fc7811e16db3c7608a2ebc72d9642
152 lines
4.9 KiB
C++
152 lines
4.9 KiB
C++
/*
|
|
* Copyright (C) 2011 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <gui/IDisplayEventConnection.h>
|
|
#include <gui/DisplayEventReceiver.h>
|
|
|
|
#include <utils/Errors.h>
|
|
|
|
#include "DisplayHardware/DisplayHardware.h"
|
|
#include "DisplayEventConnection.h"
|
|
#include "EventThread.h"
|
|
#include "SurfaceFlinger.h"
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
namespace android {
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
EventThread::EventThread(const sp<SurfaceFlinger>& flinger)
|
|
: mFlinger(flinger),
|
|
mHw(flinger->graphicPlane(0).displayHardware()),
|
|
mDeliveredEvents(0)
|
|
{
|
|
}
|
|
|
|
void EventThread::onFirstRef() {
|
|
run("EventThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);
|
|
}
|
|
|
|
status_t EventThread::registerDisplayEventConnection(
|
|
const sp<DisplayEventConnection>& connection) {
|
|
Mutex::Autolock _l(mLock);
|
|
mDisplayEventConnections.add(connection);
|
|
mCondition.signal();
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t EventThread::unregisterDisplayEventConnection(
|
|
const wp<DisplayEventConnection>& connection) {
|
|
Mutex::Autolock _l(mLock);
|
|
mDisplayEventConnections.remove(connection);
|
|
mCondition.signal();
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t EventThread::removeDisplayEventConnection(
|
|
const wp<DisplayEventConnection>& connection) {
|
|
Mutex::Autolock _l(mLock);
|
|
mDisplayEventConnections.remove(connection);
|
|
return NO_ERROR;
|
|
}
|
|
|
|
bool EventThread::threadLoop() {
|
|
|
|
nsecs_t timestamp;
|
|
DisplayEventReceiver::Event vsync;
|
|
SortedVector<wp<DisplayEventConnection> > displayEventConnections;
|
|
|
|
{ // scope for the lock
|
|
Mutex::Autolock _l(mLock);
|
|
do {
|
|
// wait for listeners
|
|
while (!mDisplayEventConnections.size()) {
|
|
mCondition.wait(mLock);
|
|
}
|
|
|
|
// wait for vsync
|
|
mLock.unlock();
|
|
timestamp = mHw.waitForVSync();
|
|
mLock.lock();
|
|
|
|
// make sure we still have some listeners
|
|
} while (!mDisplayEventConnections.size());
|
|
|
|
|
|
// dispatch vsync events to listeners...
|
|
mDeliveredEvents++;
|
|
|
|
vsync.header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
|
|
vsync.header.timestamp = timestamp;
|
|
vsync.vsync.count = mDeliveredEvents;
|
|
|
|
// make a copy of our connection list, so we can
|
|
// dispatch events without holding mLock
|
|
displayEventConnections = mDisplayEventConnections;
|
|
}
|
|
|
|
const size_t count = displayEventConnections.size();
|
|
for (size_t i=0 ; i<count ; i++) {
|
|
sp<DisplayEventConnection> conn(displayEventConnections.itemAt(i).promote());
|
|
// make sure the connection didn't die
|
|
if (conn != NULL) {
|
|
status_t err = conn->postEvent(vsync);
|
|
if (err == -EAGAIN || err == -EWOULDBLOCK) {
|
|
// The destination doesn't accept events anymore, it's probably
|
|
// full. For now, we just drop the events on the floor.
|
|
// Note that some events cannot be dropped and would have to be
|
|
// re-sent later. Right-now we don't have the ability to do
|
|
// this, but it doesn't matter for VSYNC.
|
|
} else if (err < 0) {
|
|
// handle any other error on the pipe as fatal. the only
|
|
// reasonable thing to do is to clean-up this connection.
|
|
// The most common error we'll get here is -EPIPE.
|
|
removeDisplayEventConnection(displayEventConnections.itemAt(i));
|
|
}
|
|
} else {
|
|
// somehow the connection is dead, but we still have it in our list
|
|
// just clean the list.
|
|
removeDisplayEventConnection(displayEventConnections.itemAt(i));
|
|
}
|
|
}
|
|
|
|
// clear all our references without holding mLock
|
|
displayEventConnections.clear();
|
|
|
|
return true;
|
|
}
|
|
|
|
status_t EventThread::readyToRun() {
|
|
LOGI("EventThread ready to run.");
|
|
return NO_ERROR;
|
|
}
|
|
|
|
void EventThread::dump(String8& result, char* buffer, size_t SIZE) const {
|
|
Mutex::Autolock _l(mLock);
|
|
result.append("VSYNC state:\n");
|
|
snprintf(buffer, SIZE, " numListeners=%u, events-delivered: %u\n",
|
|
mDisplayEventConnections.size(), mDeliveredEvents);
|
|
result.append(buffer);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
}; // namespace android
|