From 68d3478860fecc9b8fbf256796a832a037434555 Mon Sep 17 00:00:00 2001 From: Mathias Agopian Date: Fri, 14 Jan 2011 17:37:42 -0800 Subject: partially fix [3306150] HTML5 video with H/W acceleration blackout (DO NOT MERGE) We used to guarantee that a layer in SurfaceFlinger would never be destroyed before all references (to its ISurface) on the client side would be released. At some point, this guarantee got relaxed to allow to free gralloc resources sooner. This last change was incorrect, because: - in implementations with reference-counting the gralloc resources wouldn't be released anyways, until all the mapping were gone - in implementations without ref counting, the client side would most likely crash or do something bad - it also caused the SharedBufferStack slot to be reallocated to another surface, which could be problematic if the client continued to use the surface after the window manager destroyed it. So, we essentially reinstate the guarantee that layers won't be destroyed until after all references to their ISurface are released. NOTE: This doesn't entirely fix 3306150 because there is another problem there where the Browser continues to use a surface after it has been destroyed. also improve SurfaceFlinger 'dumpsys' log list the purgatory, which shows windows that have been closed, but for which the client still has references. --- libs/ui/GraphicBufferAllocator.cpp | 2 +- services/surfaceflinger/LayerBase.cpp | 12 ++++++++ services/surfaceflinger/LayerBase.h | 2 ++ services/surfaceflinger/SurfaceFlinger.cpp | 45 +++++++++++++++++++++++++++++- services/surfaceflinger/SurfaceFlinger.h | 1 + 5 files changed, 60 insertions(+), 2 deletions(-) diff --git a/libs/ui/GraphicBufferAllocator.cpp b/libs/ui/GraphicBufferAllocator.cpp index fa46ab7..9847a5f 100644 --- a/libs/ui/GraphicBufferAllocator.cpp +++ b/libs/ui/GraphicBufferAllocator.cpp @@ -63,7 +63,7 @@ void GraphicBufferAllocator::dump(String8& result) const const size_t c = list.size(); for (size_t i=0 ; i& layerBase) status_t SurfaceFlinger::purgatorizeLayer_l(const sp& layerBase) { - // remove the layer from the main list (through a transaction). + // First add the layer to the purgatory list, which makes sure it won't + // go away, then remove it from the main list (through a transaction). ssize_t err = removeLayer_l(layerBase); + if (err >= 0) { + mLayerPurgatory.add(layerBase); + } layerBase->onRemoved(); @@ -1354,6 +1358,19 @@ status_t SurfaceFlinger::destroySurface(const sp& layer) * to use the purgatory. */ status_t err = flinger->removeLayer_l(l); + if (err == NAME_NOT_FOUND) { + // The surface wasn't in the current list, which means it was + // removed already, which means it is in the purgatory, + // and need to be removed from there. + // This needs to happen from the main thread since its dtor + // must run from there (b/c of OpenGL ES). Additionally, we + // can't really acquire our internal lock from + // destroySurface() -- see postMessage() below. + ssize_t idx = flinger->mLayerPurgatory.remove(l); + LOGE_IF(idx < 0, + "layer=%p is not in the purgatory list", l.get()); + } + LOGE_IF(err<0 && err != NAME_NOT_FOUND, "error removing layer=%p (%s)", l.get(), strerror(-err)); return true; @@ -1469,8 +1486,13 @@ status_t SurfaceFlinger::dump(int fd, const Vector& args) result.append(buffer); } + /* + * Dump the visible layer list + */ const LayerVector& currentLayers = mCurrentState.layersSortedByZ; const size_t count = currentLayers.size(); + snprintf(buffer, SIZE, "Visible layers (count = %d)\n", count); + result.append(buffer); for (size_t i=0 ; i& layer(currentLayers[i]); layer->dump(result, buffer, SIZE); @@ -1480,6 +1502,24 @@ status_t SurfaceFlinger::dump(int fd, const Vector& args) layer->visibleRegionScreen.dump(result, "visibleRegionScreen"); } + /* + * Dump the layers in the purgatory + */ + + const size_t purgatorySize = mLayerPurgatory.size(); + snprintf(buffer, SIZE, "Purgatory state (%d entries)\n", purgatorySize); + result.append(buffer); + for (size_t i=0 ; i& layer(mLayerPurgatory.itemAt(i)); + layer->shortDump(result, buffer, SIZE); + } + + /* + * Dump SurfaceFlinger global state + */ + + snprintf(buffer, SIZE, "SurfaceFlinger global state\n"); + result.append(buffer); mWormholeRegion.dump(result, "WormholeRegion"); const DisplayHardware& hw(graphicPlane(0).displayHardware()); snprintf(buffer, SIZE, @@ -1505,6 +1545,9 @@ status_t SurfaceFlinger::dump(int fd, const Vector& args) result.append(buffer); } + /* + * Dump gralloc state + */ const GraphicBufferAllocator& alloc(GraphicBufferAllocator::get()); alloc.dump(result); diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h index ca57292..714a1b7 100644 --- a/services/surfaceflinger/SurfaceFlinger.h +++ b/services/surfaceflinger/SurfaceFlinger.h @@ -371,6 +371,7 @@ private: volatile int32_t mTransactionFlags; volatile int32_t mTransactionCount; Condition mTransactionCV; + SortedVector< sp > mLayerPurgatory; bool mResizeTransationPending; // protected by mStateLock (but we could use another lock) -- cgit v1.1