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

Commit 87caaf0d authored by Josh Gao's avatar Josh Gao Committed by Automerger Merge Worker
Browse files

Merge changes I0f1d59ae,I2f63bffb am: 9f7a73fc 

Original change: https://android-review.googlesource.com/c/platform/frameworks/base/+/1432973

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: I937c39caa5f28148279f2cc7c85c07b90eb3fac4
parents e5d8f603 9f7a73fc

services/core/jni/com_android_server_SystemServer.cpp

+9 −40
Original line number Diff line number Diff line
@@ -99,47 +99,17 @@ static void android_server_SystemServer_initZygoteChildHeapProfiling(JNIEnv* /* 
    android_mallopt(M_INIT_ZYGOTE_CHILD_PROFILING, nullptr, 0);

}



static int get_current_max_fd() {

    // Not actually guaranteed to be the max, but close enough for our purposes.

    int fd = open("/dev/null", O_RDONLY | O_CLOEXEC);

    LOG_ALWAYS_FATAL_IF(fd == -1, "failed to open /dev/null: %s", strerror(errno));

    close(fd);

    return fd;

}



static const char kFdLeakEnableThresholdProperty[] = "persist.sys.debug.fdtrack_enable_threshold";

static const char kFdLeakAbortThresholdProperty[] = "persist.sys.debug.fdtrack_abort_threshold";

static const char kFdLeakCheckIntervalProperty[] = "persist.sys.debug.fdtrack_interval";



static void android_server_SystemServer_spawnFdLeakCheckThread(JNIEnv*, jobject) {

    std::thread([]() {

        pthread_setname_np(pthread_self(), "FdLeakCheckThread");

        bool loaded = false;

        while (true) {

            const int enable_threshold = GetIntProperty(kFdLeakEnableThresholdProperty, 1024);

            const int abort_threshold = GetIntProperty(kFdLeakAbortThresholdProperty, 2048);

            const int check_interval = GetIntProperty(kFdLeakCheckIntervalProperty, 120);

            int max_fd = get_current_max_fd();

            if (max_fd > enable_threshold && !loaded) {

                loaded = true;

                ALOGE("fd count above threshold of %d, starting fd backtraces", enable_threshold);

                if (dlopen("libfdtrack.so", RTLD_GLOBAL) == nullptr) {

                    ALOGE("failed to load libfdtrack.so: %s", dlerror());

                }

            } else if (max_fd > abort_threshold) {

static void android_server_SystemServer_fdtrackAbort(JNIEnv*, jobject) {

    raise(BIONIC_SIGNAL_FDTRACK);



    // Wait for a bit to allow fdtrack to dump backtraces to logcat.

    std::this_thread::sleep_for(5s);



                LOG_ALWAYS_FATAL(

                    "b/140703823: aborting due to fd leak: check logs for fd "

    // Abort on a different thread to avoid ART dumping runtime stacks.

    std::thread([]() {

        LOG_ALWAYS_FATAL("b/140703823: aborting due to fd leak: check logs for fd "

                         "backtraces");

            }



            std::this_thread::sleep_for(std::chrono::seconds(check_interval));

        }

    }).detach();

    }).join();

}



static jlong android_server_SystemServer_startIncrementalService(JNIEnv* env, jclass klass,
@@ -161,8 +131,7 @@ static const JNINativeMethod gMethods[] = { 
        {"startHidlServices", "()V", (void*)android_server_SystemServer_startHidlServices},

        {"initZygoteChildHeapProfiling", "()V",

         (void*)android_server_SystemServer_initZygoteChildHeapProfiling},

        {"spawnFdLeakCheckThread", "()V",

         (void*)android_server_SystemServer_spawnFdLeakCheckThread},

        {"fdtrackAbort", "()V", (void*)android_server_SystemServer_fdtrackAbort},

        {"startIncrementalService", "()J",

         (void*)android_server_SystemServer_startIncrementalService},

        {"setIncrementalServiceSystemReady", "(J)V",

services/java/com/android/server/SystemServer.java

+66 −1
Original line number Diff line number Diff line
@@ -23,6 +23,8 @@ import static android.os.IServiceManager.DUMP_FLAG_PRIORITY_NORMAL; 
import static android.os.IServiceManager.DUMP_FLAG_PROTO;

import static android.os.Process.SYSTEM_UID;

import static android.os.Process.myPid;

import static android.system.OsConstants.O_CLOEXEC;

import static android.system.OsConstants.O_RDONLY;

import static android.view.Display.DEFAULT_DISPLAY;



import static com.android.server.utils.TimingsTraceAndSlog.SYSTEM_SERVER_TIMING_TAG;
@@ -75,6 +77,8 @@ import android.provider.DeviceConfig; 
import android.provider.Settings;

import android.server.ServerProtoEnums;

import android.sysprop.VoldProperties;

import android.system.ErrnoException;

import android.system.Os;

import android.text.TextUtils;

import android.util.DisplayMetrics;

import android.util.EventLog;
@@ -188,6 +192,7 @@ import dalvik.system.VMRuntime; 
import com.google.android.startop.iorap.IorapForwardingService;



import java.io.File;

import java.io.FileDescriptor;

import java.io.IOException;

import java.util.LinkedList;

import java.util.Locale;
@@ -394,11 +399,71 @@ public final class SystemServer { 
     */

    private static native void initZygoteChildHeapProfiling();



    private static final String SYSPROP_FDTRACK_ENABLE_THRESHOLD =

            "persist.sys.debug.fdtrack_enable_threshold";

    private static final String SYSPROP_FDTRACK_ABORT_THRESHOLD =

            "persist.sys.debug.fdtrack_abort_threshold";

    private static final String SYSPROP_FDTRACK_INTERVAL =

            "persist.sys.debug.fdtrack_interval";



    private static int getMaxFd() {

        FileDescriptor fd = null;

        try {

            fd = Os.open("/dev/null", O_RDONLY | O_CLOEXEC, 0);

            return fd.getInt$();

        } catch (ErrnoException ex) {

            Slog.e("System", "Failed to get maximum fd: " + ex);

        } finally {

            if (fd != null) {

                try {

                    Os.close(fd);

                } catch (ErrnoException ex) {

                    // If Os.close threw, something went horribly wrong.

                    throw new RuntimeException(ex);

                }

            }

        }



        return Integer.MAX_VALUE;

    }



    private static native void fdtrackAbort();



    /**

     * Spawn a thread that monitors for fd leaks.

     */

    private static native void spawnFdLeakCheckThread();

    private static void spawnFdLeakCheckThread() {

        final int enableThreshold = SystemProperties.getInt(SYSPROP_FDTRACK_ENABLE_THRESHOLD, 1024);

        final int abortThreshold = SystemProperties.getInt(SYSPROP_FDTRACK_ABORT_THRESHOLD, 2048);

        final int checkInterval = SystemProperties.getInt(SYSPROP_FDTRACK_INTERVAL, 120);



        new Thread(() -> {

            boolean enabled = false;

            while (true) {

                int maxFd = getMaxFd();

                if (maxFd > enableThreshold) {

                    // Do a manual GC to clean up fds that are hanging around as garbage.

                    System.gc();

                    maxFd = getMaxFd();

                }



                if (maxFd > enableThreshold && !enabled) {

                    Slog.i("System", "fdtrack enable threshold reached, enabling");

                    System.loadLibrary("fdtrack");

                    enabled = true;

                } else if (maxFd > abortThreshold) {

                    Slog.i("System", "fdtrack abort threshold reached, dumping and aborting");

                    fdtrackAbort();

                }



                try {

                    Thread.sleep(checkInterval);

                } catch (InterruptedException ex) {

                    continue;

                }

            }

        }).start();

    }



    /**

     * Start native Incremental Service and get its handle.