Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3c63fa47 authored by Siarhei Vishniakou's avatar Siarhei Vishniakou
Browse files

Split monitor and window ANR notification paths 

Currently, both monitors and windows share the same ANR notification
paths. This means that InputManagerService must be the one to determine
whether the ANR event belongs to a monitor or to a window.

We previously kept track of this by recording the pid inside
InputManagerService. However, there seems to be a path where the gesture
monitor process dies that does not lead to a notification of the java
layer. This resulted in having multiple registered processes.

Now, we will rely on the native layer to manage the pid and to notify
the java layer appropriately.

Bug: 175593831
Test: atest inputflinger_tests
Change-Id: Ie1f7e976dcadcf07a83f78b3ca856b5c43096e2f
parent ea2ed778

services/inputflinger/benchmarks/InputDispatcher_benchmarks.cpp

+10 −4
Original line number Diff line number Diff line
@@ -55,12 +55,18 @@ private: 
        ALOGE("There is no focused window for %s", applicationHandle->getName().c_str());

    }



    void notifyConnectionUnresponsive(const sp<IBinder>& connectionToken,

    void notifyWindowUnresponsive(const sp<IBinder>& connectionToken,

                                  const std::string& reason) override {

        ALOGE("Connection is not responding: %s", reason.c_str());

        ALOGE("Window is not responding: %s", reason.c_str());

    }



    void notifyConnectionResponsive(const sp<IBinder>& connectionToken) override {}

    void notifyWindowResponsive(const sp<IBinder>& connectionToken) override {}



    void notifyMonitorUnresponsive(int32_t pid, const std::string& reason) override {

        ALOGE("Monitor is not responding: %s", reason.c_str());

    }



    void notifyMonitorResponsive(int32_t pid) override {}



    void notifyInputChannelBroken(const sp<IBinder>&) override {}

services/inputflinger/dispatcher/Entry.h

+1 −0
Original line number Diff line number Diff line
@@ -271,6 +271,7 @@ struct CommandEntry { 
    sp<IBinder> newToken;

    std::string obscuringPackage;

    bool enabled;

    int32_t pid;

};



} // namespace android::inputdispatcher

services/inputflinger/dispatcher/InputDispatcher.cpp

+133 −30
Original line number Diff line number Diff line
@@ -453,6 +453,20 @@ static KeyEvent createKeyEvent(const KeyEntry& entry) { 
    return event;

}



static std::optional<int32_t> findMonitorPidByToken(

        const std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay,

        const sp<IBinder>& token) {

    for (const auto& it : monitorsByDisplay) {

        const std::vector<Monitor>& monitors = it.second;

        for (const Monitor& monitor : monitors) {

            if (monitor.inputChannel->getConnectionToken() == token) {

                return monitor.pid;

            }

        }

    }

    return std::nullopt;

}



// --- InputDispatcher ---



InputDispatcher::InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy)
@@ -615,7 +629,7 @@ nsecs_t InputDispatcher::processAnrsLocked() { 
    connection->responsive = false;

    // Stop waking up for this unresponsive connection

    mAnrTracker.eraseToken(connection->inputChannel->getConnectionToken());

    onAnrLocked(*connection);

    onAnrLocked(connection);

    return LONG_LONG_MIN;

}
@@ -5148,6 +5162,14 @@ std::optional<int32_t> InputDispatcher::findGestureMonitorDisplayByTokenLocked( 
    return std::nullopt;

}



std::optional<int32_t> InputDispatcher::findMonitorPidByTokenLocked(const sp<IBinder>& token) {

    std::optional<int32_t> gesturePid = findMonitorPidByToken(mGestureMonitorsByDisplay, token);

    if (gesturePid.has_value()) {

        return gesturePid;

    }

    return findMonitorPidByToken(mGlobalMonitorsByDisplay, token);

}



sp<Connection> InputDispatcher::getConnectionLocked(const sp<IBinder>& inputConnectionToken) const {

    if (inputConnectionToken == nullptr) {

        return nullptr;
@@ -5208,12 +5230,15 @@ void InputDispatcher::notifyFocusChangedLocked(const sp<IBinder>& oldToken, 
    postCommandLocked(std::move(commandEntry));

}



void InputDispatcher::onAnrLocked(const Connection& connection) {

void InputDispatcher::onAnrLocked(const sp<Connection>& connection) {

    if (connection == nullptr) {

        LOG_ALWAYS_FATAL("Caller must check for nullness");

    }

    // Since we are allowing the policy to extend the timeout, maybe the waitQueue

    // is already healthy again. Don't raise ANR in this situation

    if (connection.waitQueue.empty()) {

    if (connection->waitQueue.empty()) {

        ALOGI("Not raising ANR because the connection %s has recovered",

              connection.inputChannel->getName().c_str());

              connection->inputChannel->getName().c_str());

        return;

    }

    /**
@@ -5224,21 +5249,20 @@ void InputDispatcher::onAnrLocked(const Connection& connection) { 
     * processes the events linearly. So providing information about the oldest entry seems to be

     * most useful.

     */

    DispatchEntry* oldestEntry = *connection.waitQueue.begin();

    DispatchEntry* oldestEntry = *connection->waitQueue.begin();

    const nsecs_t currentWait = now() - oldestEntry->deliveryTime;

    std::string reason =

            android::base::StringPrintf("%s is not responding. Waited %" PRId64 "ms for %s",

                                        connection.inputChannel->getName().c_str(),

                                        connection->inputChannel->getName().c_str(),

                                        ns2ms(currentWait),

                                        oldestEntry->eventEntry->getDescription().c_str());

    sp<IBinder> connectionToken = connection.inputChannel->getConnectionToken();

    sp<IBinder> connectionToken = connection->inputChannel->getConnectionToken();

    updateLastAnrStateLocked(getWindowHandleLocked(connectionToken), reason);



    std::unique_ptr<CommandEntry> commandEntry = std::make_unique<CommandEntry>(

            &InputDispatcher::doNotifyConnectionUnresponsiveLockedInterruptible);

    commandEntry->connectionToken = connectionToken;

    commandEntry->reason = std::move(reason);

    postCommandLocked(std::move(commandEntry));

    processConnectionUnresponsiveLocked(*connection, std::move(reason));



    // Stop waking up for events on this connection, it is already unresponsive

    cancelEventsForAnrLocked(connection);

}



void InputDispatcher::onAnrLocked(std::shared_ptr<InputApplicationHandle> application) {
@@ -5323,26 +5347,34 @@ void InputDispatcher::doNotifyNoFocusedWindowAnrLockedInterruptible(CommandEntry 
    mLock.lock();

}



void InputDispatcher::doNotifyConnectionUnresponsiveLockedInterruptible(

        CommandEntry* commandEntry) {

void InputDispatcher::doNotifyWindowUnresponsiveLockedInterruptible(CommandEntry* commandEntry) {

    mLock.unlock();



    mPolicy->notifyConnectionUnresponsive(commandEntry->connectionToken, commandEntry->reason);

    mPolicy->notifyWindowUnresponsive(commandEntry->connectionToken, commandEntry->reason);



    mLock.lock();

}



    // stop waking up for events in this connection, it is already not responding

    sp<Connection> connection = getConnectionLocked(commandEntry->connectionToken);

    if (connection == nullptr) {

        return;

void InputDispatcher::doNotifyMonitorUnresponsiveLockedInterruptible(CommandEntry* commandEntry) {

    mLock.unlock();



    mPolicy->notifyMonitorUnresponsive(commandEntry->pid, commandEntry->reason);



    mLock.lock();

}

    cancelEventsForAnrLocked(connection);



void InputDispatcher::doNotifyWindowResponsiveLockedInterruptible(CommandEntry* commandEntry) {

    mLock.unlock();



    mPolicy->notifyWindowResponsive(commandEntry->connectionToken);



    mLock.lock();

}



void InputDispatcher::doNotifyConnectionResponsiveLockedInterruptible(CommandEntry* commandEntry) {

void InputDispatcher::doNotifyMonitorResponsiveLockedInterruptible(CommandEntry* commandEntry) {

    mLock.unlock();



    mPolicy->notifyConnectionResponsive(commandEntry->connectionToken);

    mPolicy->notifyMonitorResponsive(commandEntry->pid);



    mLock.lock();

}
@@ -5447,13 +5479,8 @@ void InputDispatcher::doDispatchCycleFinishedLockedInterruptible(CommandEntry* c 
        if (!connection->responsive) {

            connection->responsive = isConnectionResponsive(*connection);

            if (connection->responsive) {

                // The connection was unresponsive, and now it's responsive. Tell the policy

                // about it so that it can stop ANR.

                std::unique_ptr<CommandEntry> connectionResponsiveCommand =

                        std::make_unique<CommandEntry>(

                                &InputDispatcher::doNotifyConnectionResponsiveLockedInterruptible);

                connectionResponsiveCommand->connectionToken = connectionToken;

                postCommandLocked(std::move(connectionResponsiveCommand));

                // The connection was unresponsive, and now it's responsive.

                processConnectionResponsiveLocked(*connection);

            }

        }

        traceWaitQueueLength(connection);
@@ -5469,6 +5496,82 @@ void InputDispatcher::doDispatchCycleFinishedLockedInterruptible(CommandEntry* c 
    startDispatchCycleLocked(now(), connection);

}



void InputDispatcher::sendMonitorUnresponsiveCommandLocked(int32_t pid, std::string reason) {

    std::unique_ptr<CommandEntry> monitorUnresponsiveCommand = std::make_unique<CommandEntry>(

            &InputDispatcher::doNotifyMonitorUnresponsiveLockedInterruptible);

    monitorUnresponsiveCommand->pid = pid;

    monitorUnresponsiveCommand->reason = std::move(reason);

    postCommandLocked(std::move(monitorUnresponsiveCommand));

}



void InputDispatcher::sendWindowUnresponsiveCommandLocked(sp<IBinder> connectionToken,

                                                          std::string reason) {

    std::unique_ptr<CommandEntry> windowUnresponsiveCommand = std::make_unique<CommandEntry>(

            &InputDispatcher::doNotifyWindowUnresponsiveLockedInterruptible);

    windowUnresponsiveCommand->connectionToken = std::move(connectionToken);

    windowUnresponsiveCommand->reason = std::move(reason);

    postCommandLocked(std::move(windowUnresponsiveCommand));

}



void InputDispatcher::sendMonitorResponsiveCommandLocked(int32_t pid) {

    std::unique_ptr<CommandEntry> monitorResponsiveCommand = std::make_unique<CommandEntry>(

            &InputDispatcher::doNotifyMonitorResponsiveLockedInterruptible);

    monitorResponsiveCommand->pid = pid;

    postCommandLocked(std::move(monitorResponsiveCommand));

}



void InputDispatcher::sendWindowResponsiveCommandLocked(sp<IBinder> connectionToken) {

    std::unique_ptr<CommandEntry> windowResponsiveCommand = std::make_unique<CommandEntry>(

            &InputDispatcher::doNotifyWindowResponsiveLockedInterruptible);

    windowResponsiveCommand->connectionToken = std::move(connectionToken);

    postCommandLocked(std::move(windowResponsiveCommand));

}



/**

 * Tell the policy that a connection has become unresponsive so that it can start ANR.

 * Check whether the connection of interest is a monitor or a window, and add the corresponding

 * command entry to the command queue.

 */

void InputDispatcher::processConnectionUnresponsiveLocked(const Connection& connection,

                                                          std::string reason) {

    const sp<IBinder>& connectionToken = connection.inputChannel->getConnectionToken();

    if (connection.monitor) {

        ALOGW("Monitor %s is unresponsive: %s", connection.inputChannel->getName().c_str(),

              reason.c_str());

        std::optional<int32_t> pid = findMonitorPidByTokenLocked(connectionToken);

        if (!pid.has_value()) {

            ALOGE("Could not find unresponsive monitor for connection %s",

                  connection.inputChannel->getName().c_str());

            return;

        }

        sendMonitorUnresponsiveCommandLocked(pid.value(), std::move(reason));

        return;

    }

    // If not a monitor, must be a window

    ALOGW("Window %s is unresponsive: %s", connection.inputChannel->getName().c_str(),

          reason.c_str());

    sendWindowUnresponsiveCommandLocked(connectionToken, std::move(reason));

}



/**

 * Tell the policy that a connection has become responsive so that it can stop ANR.

 */

void InputDispatcher::processConnectionResponsiveLocked(const Connection& connection) {

    const sp<IBinder>& connectionToken = connection.inputChannel->getConnectionToken();

    if (connection.monitor) {

        std::optional<int32_t> pid = findMonitorPidByTokenLocked(connectionToken);

        if (!pid.has_value()) {

            ALOGE("Could not find responsive monitor for connection %s",

                  connection.inputChannel->getName().c_str());

            return;

        }

        sendMonitorResponsiveCommandLocked(pid.value());

        return;

    }

    // If not a monitor, must be a window

    sendWindowResponsiveCommandLocked(connectionToken);

}



bool InputDispatcher::afterKeyEventLockedInterruptible(const sp<Connection>& connection,

                                                       DispatchEntry* dispatchEntry,

                                                       KeyEntry& keyEntry, bool handled) {

services/inputflinger/dispatcher/InputDispatcher.h

+37 −5
Original line number Diff line number Diff line
@@ -233,6 +233,8 @@ private: 
    // Finds the display ID of the gesture monitor identified by the provided token.

    std::optional<int32_t> findGestureMonitorDisplayByTokenLocked(const sp<IBinder>& token)

            REQUIRES(mLock);

    // Find a monitor pid by the provided token.

    std::optional<int32_t> findMonitorPidByTokenLocked(const sp<IBinder>& token) REQUIRES(mLock);



    // Input channels that will receive a copy of all input events sent to the provided display.

    std::unordered_map<int32_t, std::vector<Monitor>> mGlobalMonitorsByDisplay GUARDED_BY(mLock);
@@ -432,6 +434,34 @@ private: 
    int32_t mAwaitedApplicationDisplayId GUARDED_BY(mLock);

    void processNoFocusedWindowAnrLocked() REQUIRES(mLock);



    /**

     * Tell policy about a window or a monitor that just became unresponsive. Starts ANR.

     */

    void processConnectionUnresponsiveLocked(const Connection& connection, std::string reason)

            REQUIRES(mLock);

    /**

     * Tell policy about a window or a monitor that just became responsive.

     */

    void processConnectionResponsiveLocked(const Connection& connection) REQUIRES(mLock);



    /**

     * Post `doNotifyMonitorUnresponsiveLockedInterruptible` command.

     */

    void sendMonitorUnresponsiveCommandLocked(int32_t pid, std::string reason) REQUIRES(mLock);

    /**

     * Post `doNotifyWindowUnresponsiveLockedInterruptible` command.

     */

    void sendWindowUnresponsiveCommandLocked(sp<IBinder> connectionToken, std::string reason)

            REQUIRES(mLock);

    /**

     * Post `doNotifyMonitorResponsiveLockedInterruptible` command.

     */

    void sendMonitorResponsiveCommandLocked(int32_t pid) REQUIRES(mLock);

    /**

     * Post `doNotifyWindowResponsiveLockedInterruptible` command.

     */

    void sendWindowResponsiveCommandLocked(sp<IBinder> connectionToken) REQUIRES(mLock);



    /**

     * This map will store the pending focus requests that cannot be currently processed. This can

     * happen if the window requested to be focused is not currently visible. Such a window might
@@ -577,7 +607,7 @@ private: 
                              int32_t displayId, std::string_view reason) REQUIRES(mLock);

    void notifyFocusChangedLocked(const sp<IBinder>& oldFocus, const sp<IBinder>& newFocus)

            REQUIRES(mLock);

    void onAnrLocked(const Connection& connection) REQUIRES(mLock);

    void onAnrLocked(const sp<Connection>& connection) REQUIRES(mLock);

    void onAnrLocked(std::shared_ptr<InputApplicationHandle> application) REQUIRES(mLock);

    void onUntrustedTouchLocked(const std::string& obscuringPackage) REQUIRES(mLock);

    void updateLastAnrStateLocked(const sp<InputWindowHandle>& window, const std::string& reason)
@@ -592,11 +622,13 @@ private: 
            REQUIRES(mLock);

    void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);

    void doNotifyFocusChangedLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);

    // ANR-related callbacks - start

    void doNotifyNoFocusedWindowAnrLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);

    void doNotifyConnectionUnresponsiveLockedInterruptible(CommandEntry* commandEntry)

            REQUIRES(mLock);

    void doNotifyConnectionResponsiveLockedInterruptible(CommandEntry* commandEntry)

            REQUIRES(mLock);

    void doNotifyWindowUnresponsiveLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);

    void doNotifyMonitorUnresponsiveLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);

    void doNotifyWindowResponsiveLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);

    void doNotifyMonitorResponsiveLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);

    // ANR-related callbacks - end

    void doNotifySensorLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);

    void doNotifyUntrustedTouchLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);

    void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry)

services/inputflinger/dispatcher/include/InputDispatcherPolicyInterface.h

+19 −8
Original line number Diff line number Diff line
@@ -50,20 +50,31 @@ public: 
    virtual void notifyNoFocusedWindowAnr(

            const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) = 0;



    /* Notifies the system that a connection just became unresponsive. This indicates that ANR

     * should be raised for this connection. The connection is identified via token.

    /* Notifies the system that a window just became unresponsive. This indicates that ANR

     * should be raised for this window. The window is identified via token.

     * The string reason contains information about the input event that we haven't received

     * a response for.

     */

    virtual void notifyConnectionUnresponsive(const sp<IBinder>& token,

                                              const std::string& reason) = 0;

    virtual void notifyWindowUnresponsive(const sp<IBinder>& token, const std::string& reason) = 0;

    /* Notifies the system that a monitor just became unresponsive. This indicates that ANR

     * should be raised for this monitor. The monitor is identified via its pid.

     * The string reason contains information about the input event that we haven't received

     * a response for.

     */

    virtual void notifyMonitorUnresponsive(int32_t pid, const std::string& reason) = 0;



    /* Notifies the system that a connection just became responsive. This is only called after the

     * connection was first marked "unresponsive". This indicates that ANR dialog (if any) should

     * no longer should be shown to the user. The connection is eligible to cause a new ANR in the

    /* Notifies the system that a window just became responsive. This is only called after the

     * window was first marked "unresponsive". This indicates that ANR dialog (if any) should

     * no longer should be shown to the user. The window is eligible to cause a new ANR in the

     * future.

     */

    virtual void notifyWindowResponsive(const sp<IBinder>& token) = 0;

    /* Notifies the system that a monitor just became responsive. This is only called after the

     * monitor was first marked "unresponsive". This indicates that ANR dialog (if any) should

     * no longer should be shown to the user. The monitor is eligible to cause a new ANR in the

     * future.

     */

    virtual void notifyConnectionResponsive(const sp<IBinder>& token) = 0;

    virtual void notifyMonitorResponsive(int32_t pid) = 0;



    /* Notifies the system that an input channel is unrecoverably broken. */

    virtual void notifyInputChannelBroken(const sp<IBinder>& token) = 0;